
// Generated from ./parser/grammar/FormalParser.g4 by ANTLR 4.8

#pragma once


#include <string>
#include <optional>
#include "../cyclone_parser_base.h"
#include "../syntax_error_formatter.hpp"


#include "antlr4-runtime.h"


using boolean = bool;
using CppString = std::string;
using namespace cyclone::parser;


namespace cyclone {


//TODO


class  FormalParser : public CycloneParserBase {
public:
  enum {
    MultiLineComment = 1, SingleLineComment = 2, RegularExpressionLiteral = 3, 
    OpenBracket = 4, CloseBracket = 5, OpenParen = 6, CloseParen = 7, OpenBrace = 8, 
    TemplateCloseBrace = 9, CloseBrace = 10, SemiColon = 11, Comma = 12, 
    Assign = 13, QuestionMark = 14, Colon = 15, Ellipsis = 16, Dot = 17, 
    PlusPlus = 18, MinusMinus = 19, Plus = 20, Minus = 21, BitNot = 22, 
    Not = 23, Multiply = 24, Divide = 25, Modulus = 26, Exponentiation = 27, 
    Hashtag = 28, RightShiftArithmetic = 29, LeftShiftArithmetic = 30, RightShiftLogical = 31, 
    LessThan = 32, MoreThan = 33, LessThanEquals = 34, GreaterThanEquals = 35, 
    Equals_ = 36, NotEquals = 37, IdentityEquals = 38, IdentityNotEquals = 39, 
    BitAnd = 40, BitXOr = 41, BitOr = 42, And = 43, Or = 44, DoubleQuestionMark = 45, 
    OptionalChainingOperator = 46, MultiplyAssign = 47, DivideAssign = 48, 
    ModulusAssign = 49, ExponentiationAssign = 50, PlusAssign = 51, MinusAssign = 52, 
    LeftShiftArithmeticAssign = 53, RightShiftArithmeticAssign = 54, RightShiftLogicalAssign = 55, 
    BitAndAssign = 56, BitXorAssign = 57, BitOrAssign = 58, ARROW = 59, 
    NullLiteral = 60, BooleanLiteral = 61, DecimalLiteral = 62, HexIntegerLiteral = 63, 
    OctalIntegerLiteral = 64, OctalIntegerLiteral2 = 65, BinaryIntegerLiteral = 66, 
    BigInt = 67, Break = 68, Do = 69, Instanceof = 70, Typeof = 71, Case = 72, 
    Else = 73, New = 74, Var = 75, Catch = 76, Finally = 77, Return = 78, 
    Void = 79, Continue = 80, For = 81, Switch = 82, While = 83, Debugger = 84, 
    Function_ = 85, This = 86, With = 87, Default = 88, If = 89, Throw = 90, 
    Delete = 91, In = 92, Of = 93, Try = 94, As = 95, From = 96, ReadOnly = 97, 
    Async = 98, Class = 99, Enum = 100, Extends = 101, Super = 102, Const = 103, 
    Export = 104, Import = 105, Implements = 106, Let = 107, Private = 108, 
    Public = 109, Interface = 110, Package = 111, Protected = 112, Static = 113, 
    Yield = 114, Await = 115, Any = 116, Number = 117, Boolean = 118, String = 119, 
    Symbol = 120, Undefined = 121, BigIntAnnotation = 122, Int8 = 123, Int16 = 124, 
    Int32 = 125, Int64 = 126, Uint8 = 127, Uint16 = 128, Uint32 = 129, Uint64 = 130, 
    Float = 131, Double = 132, Decimal = 133, Array = 134, Object = 135, 
    Tuple = 136, Struct = 137, Union = 138, Variant = 139, TypeAlias = 140, 
    Get = 141, Set = 142, Constructor = 143, Namespace = 144, Module = 145, 
    Declare = 146, Abstract = 147, Is = 148, At = 149, SingQuote = 150, 
    DoubleQuote = 151, QuestionMarkFollowedByDecimalDirectly = 152, Identifier = 153, 
    StringLiteral = 154, BackTick = 155, WhiteSpaces = 156, LineTerminator = 157, 
    HtmlComment = 158, CDataComment = 159, UnexpectedCharacter = 160, TemplateStringStartExpression = 161, 
    TemplateStringAtom = 162
  };

  enum {
    RuleInput = 0, RuleVardecl = 1, RuleOutput = 2, RulePattern = 3, RuleAssignmentPattern = 4, 
    RuleInitializer = 5, RuleParameterList = 6, RuleParameter = 7, RuleAdvancedParameterList = 8, 
    RuleRequiredParameterList = 9, RuleAdvancedParameter = 10, RuleOptionalParameter = 11, 
    RuleRequiredParameter = 12, RuleAccessibilityModifier = 13, RuleInterfaceExtendsClause = 14, 
    RuleClassOrInterfaceTypeList = 15, RuleEnumDeclaration = 16, RuleEnumBody = 17, 
    RuleEnumMemberList = 18, RuleEnumMember = 19, RuleImportAliasDeclaration = 20, 
    RuleProgram = 21, RuleSourceElement = 22, RuleStatement = 23, RuleBraceBlock = 24, 
    RuleDeclaration = 25, RuleFunctionDeclaration = 26, RuleBaseFunction = 27, 
    RuleBaseClass = 28, RuleStatementList = 29, RuleFromBlock = 30, RuleMultipleImportStatement = 31, 
    RuleVariableDeclaration = 32, RuleVariableDeclaratorList = 33, RuleVariableDeclarator = 34, 
    RuleForInitStatement = 35, RuleBaseForXStatement = 36, RuleVarModifier = 37, 
    RuleSwitchCaseList = 38, RuleCaseClauses = 39, RuleCaseClause = 40, 
    RuleDefaultClause = 41, RuleCatchProduction = 42, RuleFinallyProduction = 43, 
    RuleClassBody = 44, RuleClassExtendsClause = 45, RuleImplementsClause = 46, 
    RuleClassElement = 47, RuleMethodDefinition = 48, RulePropertyDefinition = 49, 
    RuleGeneratorMethod = 50, RuleGeneratorFunctionDeclaration = 51, RuleGeneratorBlock = 52, 
    RuleGeneratorDefinition = 53, RuleIteratorBlock = 54, RuleIteratorDefinition = 55, 
    RuleFunctionBody = 56, RuleSourceArrayList = 57, RuleSpreadElement = 58, 
    RuleArrayElement = 59, RuleArrayElementArrayList = 60, RuleArrayPatternElementArrayList = 61, 
    RuleObjectElement = 62, RuleObjectElementArrayList = 63, RulePropertyName = 64, 
    RulePropertyKey = 65, RuleProperty = 66, RuleAssignmentProperty = 67, 
    RuleObjectPatternElement = 68, RuleObjectPatternElementArrayList = 69, 
    RuleGetAccessor = 70, RuleSetAccessor = 71, RuleArgumentArrayList = 72, 
    RuleArgument = 73, RuleExpressionSequence = 74, RuleUpdateOperator = 75, 
    RuleUnaryOperator = 76, RuleExponentiationOperator = 77, RuleMultiplicativeOperator = 78, 
    RuleAdditiveOperator = 79, RuleBitShiftOperator = 80, RuleRelationalOperator = 81, 
    RuleInstanceofOperator = 82, RuleInOperator = 83, RuleEqualityOperator = 84, 
    RuleBitAndOperator = 85, RuleBitOrOperator = 86, RuleBitXorOperator = 87, 
    RuleExpression = 88, RuleIdentifier = 89, RuleMetaPropertyIdentifier = 90, 
    RulePrivateIdentifier = 91, RuleMemberExpressionProperty = 92, RuleArrowFunctionParameters = 93, 
    RuleArrowFunctionBody = 94, RuleAssignmentOperator = 95, RuleNumericLiteral = 96, 
    RuleLiteral = 97, RuleTemplateLiteral = 98, RuleTemplateStringAtom = 99, 
    RuleKeyword = 100, RuleGetter = 101, RuleSetter = 102, RuleEos = 103, 
    RuleAssignable = 104, RuleTypeAnnotation = 105, RuleQualifiedName = 106, 
    RuleTypeName = 107, RuleJsPrimitiveType = 108, RuleExtendedPrimitiveType = 109, 
    RuleTypeList = 110, RuleAnonymousObjectPropertyListSeparator = 111, 
    RuleAnonymousObjectPropertyList = 112, RuleObjectPropertyPair = 113, 
    RuleGenericKind = 114, RuleCommaGeneric = 115, RuleAngleGeneric = 116, 
    RuleObjectOrArrayGenericType = 117, RuleType_ = 118, RuleTypeAnnot = 119, 
    RuleTypePredicate = 120, RuleFunctionReturnType = 121
  };
  enum {
    ContextIdInput,   ContextIdVardecl,   ContextIdOutput,   ContextIdPattern,  
                                                                                ContextIdArrayPattern,  
                                                                                ContextIdRestElement,  
                                                                                ContextIdObjectPattern,  
                                                                                ContextIdIdentifierPattern,   
    ContextIdAssignmentPattern,   ContextIdInitializer,   ContextIdParameterList,   
    ContextIdParameter,   ContextIdAdvancedParameterList,   ContextIdRequiredParameterList,   
    ContextIdAdvancedParameter,   ContextIdOptionalParameter,   ContextIdRequiredParameter,   
    ContextIdAccessibilityModifier,   ContextIdInterfaceExtendsClause,   
    ContextIdClassOrInterfaceTypeList,   ContextIdEnumDeclaration,   ContextIdEnumBody,   
    ContextIdEnumMemberList,   ContextIdEnumMember,   ContextIdImportAliasDeclaration,   
    ContextIdProgram,   ContextIdSourceElement,   ContextIdStatement,  ContextIdExportStatement,  
                                                                       ContextIdTSEnumDeclaration,  
                                                                       ContextIdEmptyStatement,  
                                                                       ContextIdBlockStatement,  
                                                                       ContextIdImportStatement,  
                                                                       ContextIdWhileStatement,  
                                                                       ContextIdWithStatement,  
                                                                       ContextIdBreakStatement,  
                                                                       ContextIdIfStatement,  
                                                                       ContextIdSwitchStatement,  
                                                                       ContextIdTSModuleDeclaration,  
                                                                       ContextIdLabeledStatement,  
                                                                       ContextIdTryStatement,  
                                                                       ContextIdExpressionStatement,  
                                                                       ContextIdReturnStatement,  
                                                                       ContextIdThrowStatement,  
                                                                       ContextIdTSTypeAliasDeclaration,  
                                                                       ContextIdForStatement,  
                                                                       ContextIdDoWhileStatement,  
                                                                       ContextIdForInStatement,  
                                                                       ContextIdContinueStatement,  
                                                                       ContextIdDebuggerStatement,  
                                                                       ContextIdForOfStatement,  
                                                                       ContextIdDeclarationStatement,   
    ContextIdBraceBlock,   ContextIdDeclaration,   ContextIdFunctionDeclaration,   
    ContextIdBaseFunction,   ContextIdBaseClass,   ContextIdStatementList,   
    ContextIdFromBlock,   ContextIdMultipleImportStatement,   ContextIdVariableDeclaration,   
    ContextIdVariableDeclaratorList,   ContextIdVariableDeclarator,   ContextIdForInitStatement,   
    ContextIdBaseForXStatement,   ContextIdVarModifier,   ContextIdSwitchCaseList,   
    ContextIdCaseClauses,   ContextIdCaseClause,   ContextIdDefaultClause,   
    ContextIdCatchProduction,   ContextIdFinallyProduction,   ContextIdClassBody,   
    ContextIdClassExtendsClause,   ContextIdImplementsClause,   ContextIdClassElement,   
    ContextIdMethodDefinition,   ContextIdPropertyDefinition,   ContextIdGeneratorMethod,   
    ContextIdGeneratorFunctionDeclaration,   ContextIdGeneratorBlock,   
    ContextIdGeneratorDefinition,   ContextIdIteratorBlock,   ContextIdIteratorDefinition,   
    ContextIdFunctionBody,   ContextIdSourceArrayList,   ContextIdSpreadElement,   
    ContextIdArrayElement,   ContextIdArrayElementArrayList,   ContextIdArrayPatternElementArrayList,   
    ContextIdObjectElement,   ContextIdObjectElementArrayList,   ContextIdPropertyName,   
    ContextIdPropertyKey,   ContextIdProperty,  ContextIdPropertyExpressionAssignment,  
                                                ContextIdComputedPropertyExpressionAssignment,  
                                                ContextIdPropertyShorthand,  
                                                ContextIdPropertySetter,  
                                                ContextIdPropertyGetter,  
                                                ContextIdMethodProperty,   
    ContextIdAssignmentProperty,  ContextIdShorthandAssignmentProperty,  
                                  ContextIdAssignmentPatternInObject,   
    ContextIdObjectPatternElement,   ContextIdObjectPatternElementArrayList,   
    ContextIdGetAccessor,   ContextIdSetAccessor,   ContextIdArgumentArrayList,   
    ContextIdArgument,   ContextIdExpressionSequence,   ContextIdUpdateOperator,   
    ContextIdUnaryOperator,   ContextIdExponentiationOperator,   ContextIdMultiplicativeOperator,   
    ContextIdAdditiveOperator,   ContextIdBitShiftOperator,   ContextIdRelationalOperator,   
    ContextIdInstanceofOperator,   ContextIdInOperator,   ContextIdEqualityOperator,   
    ContextIdBitAndOperator,   ContextIdBitOrOperator,   ContextIdBitXorOperator,   
    ContextIdExpression,  ContextIdGeneratorsExpression,  ContextIdExponentiationExpression,  
                          ContextIdPatternInvolvedAssignmentExpression,  
                          ContextIdInExpression,  ContextIdUnaryExpression,  
                          ContextIdAwaitExpression,  ContextIdThisExpression,  
                          ContextIdLogicalExpression,  ContextIdFunctionExpression,  
                          ContextIdAssignmentExpression,  ContextIdTaggedTemplateExpression,  
                          ContextIdInstanceofExpression,  ContextIdGeneratorsFunctionExpression,  
                          ContextIdImportExpression,  ContextIdArrowFunctionExpression,  
                          ContextIdIteratorsExpression,  ContextIdMetaProperty,  
                          ContextIdEqualityExpression,  ContextIdUpdateExpression,  
                          ContextIdSuperExpression,  ContextIdMultiplicativeExpression,  
                          ContextIdCallExpression,  ContextIdBitShiftExpression,  
                          ContextIdParenthesizedExpression,  ContextIdAdditiveExpression,  
                          ContextIdRelationalExpression,  ContextIdYieldExpression,  
                          ContextIdQuestionMarkFollowedByDecimalDirectlyConditionExpression,  
                          ContextIdNewExpression,  ContextIdLiteralExpression,  
                          ContextIdConditionalExpression,  ContextIdBitXorExpression,  
                          ContextIdClassExpression,  ContextIdTSAsExpression,  
                          ContextIdIdentifierExpression,  ContextIdMemberExpression,  
                          ContextIdBitAndExpression,  ContextIdBitOrExpression,  
                          ContextIdArrayExpression,  ContextIdObjectExpression,  
                          ContextIdTemplateLiteralExpression,   ContextIdIdentifier,   
    ContextIdMetaPropertyIdentifier,   ContextIdPrivateIdentifier,   ContextIdMemberExpressionProperty,  
                                                                                                         ContextIdDotMemberExpression,  
                                                                                                         ContextIdPrivateMemberExpression,  
                                                                                                         ContextIdBracketMemberExpression,   
    ContextIdArrowFunctionParameters,   ContextIdArrowFunctionBody,   ContextIdAssignmentOperator,   
    ContextIdNumericLiteral,   ContextIdLiteral,   ContextIdTemplateLiteral,   
    ContextIdTemplateStringAtom,  ContextIdAtomTemplateString,  ContextIdBraceTemplateString,   
    ContextIdKeyword,   ContextIdGetter,   ContextIdSetter,   ContextIdEos,   
    ContextIdAssignable,   ContextIdTypeAnnotation,   ContextIdQualifiedName,   
    ContextIdTypeName,   ContextIdJsPrimitiveType,   ContextIdExtendedPrimitiveType,   
    ContextIdTypeList,   ContextIdAnonymousObjectPropertyListSeparator,   
    ContextIdAnonymousObjectPropertyList,   ContextIdObjectPropertyPair,   
    ContextIdGenericKind,   ContextIdCommaGeneric,   ContextIdAngleGeneric,   
    ContextIdObjectOrArrayGenericType,   ContextIdType_,  ContextIdUnionType,  
                                                          ContextIdGenericType,  
                                                          ContextIdParenthesizedPrimType,  
                                                          ContextIdTupleType,  
                                                          ContextIdPrimitiveType,  
                                                          ContextIdTypeReference,  
                                                          ContextIdStruct,   
    ContextIdTypeAnnot,   ContextIdTypePredicate,   ContextIdFunctionReturnType,   
  };

  FormalParser(antlr4::TokenStream *input);
  ~FormalParser();

  virtual std::string getGrammarFileName() const override;
  virtual const antlr4::atn::ATN& getATN() const override { return _atn; };
  virtual const std::vector<std::string>& getTokenNames() const override { return _tokenNames; }; // deprecated: use vocabulary instead.
  virtual const std::vector<std::string>& getRuleNames() const override;
  virtual antlr4::dfa::Vocabulary& getVocabulary() const override;


  /* public parser declarations/members section */

  void updateOperatorIsPrefix(antlr4::ParserRuleContext* context){
      if(auto updateOperator = dynamic_cast<UpdateOperatorContext*>(context))
          updateOperator->prefix = true;
  }


  class InputContext;
  class VardeclContext;
  class OutputContext;
  class PatternContext;
  class AssignmentPatternContext;
  class InitializerContext;
  class ParameterListContext;
  class ParameterContext;
  class AdvancedParameterListContext;
  class RequiredParameterListContext;
  class AdvancedParameterContext;
  class OptionalParameterContext;
  class RequiredParameterContext;
  class AccessibilityModifierContext;
  class InterfaceExtendsClauseContext;
  class ClassOrInterfaceTypeListContext;
  class EnumDeclarationContext;
  class EnumBodyContext;
  class EnumMemberListContext;
  class EnumMemberContext;
  class ImportAliasDeclarationContext;
  class ProgramContext;
  class SourceElementContext;
  class StatementContext;
  class BraceBlockContext;
  class DeclarationContext;
  class FunctionDeclarationContext;
  class BaseFunctionContext;
  class BaseClassContext;
  class StatementListContext;
  class FromBlockContext;
  class MultipleImportStatementContext;
  class VariableDeclarationContext;
  class VariableDeclaratorListContext;
  class VariableDeclaratorContext;
  class ForInitStatementContext;
  class BaseForXStatementContext;
  class VarModifierContext;
  class SwitchCaseListContext;
  class CaseClausesContext;
  class CaseClauseContext;
  class DefaultClauseContext;
  class CatchProductionContext;
  class FinallyProductionContext;
  class ClassBodyContext;
  class ClassExtendsClauseContext;
  class ImplementsClauseContext;
  class ClassElementContext;
  class MethodDefinitionContext;
  class PropertyDefinitionContext;
  class GeneratorMethodContext;
  class GeneratorFunctionDeclarationContext;
  class GeneratorBlockContext;
  class GeneratorDefinitionContext;
  class IteratorBlockContext;
  class IteratorDefinitionContext;
  class FunctionBodyContext;
  class SourceArrayListContext;
  class SpreadElementContext;
  class ArrayElementContext;
  class ArrayElementArrayListContext;
  class ArrayPatternElementArrayListContext;
  class ObjectElementContext;
  class ObjectElementArrayListContext;
  class PropertyNameContext;
  class PropertyKeyContext;
  class PropertyContext;
  class AssignmentPropertyContext;
  class ObjectPatternElementContext;
  class ObjectPatternElementArrayListContext;
  class GetAccessorContext;
  class SetAccessorContext;
  class ArgumentArrayListContext;
  class ArgumentContext;
  class ExpressionSequenceContext;
  class UpdateOperatorContext;
  class UnaryOperatorContext;
  class ExponentiationOperatorContext;
  class MultiplicativeOperatorContext;
  class AdditiveOperatorContext;
  class BitShiftOperatorContext;
  class RelationalOperatorContext;
  class InstanceofOperatorContext;
  class InOperatorContext;
  class EqualityOperatorContext;
  class BitAndOperatorContext;
  class BitOrOperatorContext;
  class BitXorOperatorContext;
  class ExpressionContext;
  class IdentifierContext;
  class MetaPropertyIdentifierContext;
  class PrivateIdentifierContext;
  class MemberExpressionPropertyContext;
  class ArrowFunctionParametersContext;
  class ArrowFunctionBodyContext;
  class AssignmentOperatorContext;
  class NumericLiteralContext;
  class LiteralContext;
  class TemplateLiteralContext;
  class TemplateStringAtomContext;
  class KeywordContext;
  class GetterContext;
  class SetterContext;
  class EosContext;
  class AssignableContext;
  class TypeAnnotationContext;
  class QualifiedNameContext;
  class TypeNameContext;
  class JsPrimitiveTypeContext;
  class ExtendedPrimitiveTypeContext;
  class TypeListContext;
  class AnonymousObjectPropertyListSeparatorContext;
  class AnonymousObjectPropertyListContext;
  class ObjectPropertyPairContext;
  class GenericKindContext;
  class CommaGenericContext;
  class AngleGenericContext;
  class ObjectOrArrayGenericTypeContext;
  class Type_Context;
  class TypeAnnotContext;
  class TypePredicateContext;
  class FunctionReturnTypeContext; 

  class  InputContext : public antlr4::ParserRuleContext {
  public:
    InputContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    virtual size_t getContextId() const override;
    ExpressionSequenceContext *expressionSequence();
    EosContext *eos();

   
  };

  virtual InputContext* input();

  class  VardeclContext : public antlr4::ParserRuleContext {
  public:
    VardeclContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    virtual size_t getContextId() const override;
    VariableDeclarationContext *variableDeclaration();
    EosContext *eos();

   
  };

  virtual VardeclContext* vardecl();

  class  OutputContext : public antlr4::ParserRuleContext {
  public:
    OutputContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    virtual size_t getContextId() const override;
    AssignableContext *assignable();
    EosContext *eos();

   
  };

  virtual OutputContext* output();

  class  PatternContext : public antlr4::ParserRuleContext {
  public:
    CppString type;
    PatternContext(antlr4::ParserRuleContext *parent, size_t invokingState);
   
    PatternContext() = default;
    void copyFrom(PatternContext *context);
    using antlr4::ParserRuleContext::copyFrom;

    virtual size_t getRuleIndex() const override;
    virtual size_t getContextId() const override;

   
  };

  class  ArrayPatternContext : public PatternContext {
  public:
    ArrayPatternContext(PatternContext *ctx);

    FormalParser::ArrayPatternElementArrayListContext *elements_ = nullptr;
    FormalParser::TypeAnnotationContext *typeAnnotation_ = nullptr;
    antlr4::tree::TerminalNode *OpenBracket();
    antlr4::tree::TerminalNode *CloseBracket();
    ArrayPatternElementArrayListContext *arrayPatternElementArrayList();
    TypeAnnotationContext *typeAnnotation();
    virtual size_t getContextId() const override;
  };

  class  RestElementContext : public PatternContext {
  public:
    RestElementContext(PatternContext *ctx);

    FormalParser::PatternContext *argument_ = nullptr;
    FormalParser::TypeAnnotationContext *typeAnnotation_ = nullptr;
    antlr4::tree::TerminalNode *Ellipsis();
    PatternContext *pattern();
    TypeAnnotationContext *typeAnnotation();
    virtual size_t getContextId() const override;
  };

  class  ObjectPatternContext : public PatternContext {
  public:
    ObjectPatternContext(PatternContext *ctx);

    FormalParser::ObjectPatternElementArrayListContext *properties_ = nullptr;
    FormalParser::TypeAnnotationContext *typeAnnotation_ = nullptr;
    antlr4::tree::TerminalNode *OpenBrace();
    antlr4::tree::TerminalNode *CloseBrace();
    ObjectPatternElementArrayListContext *objectPatternElementArrayList();
    TypeAnnotationContext *typeAnnotation();
    virtual size_t getContextId() const override;
  };

  class  IdentifierPatternContext : public PatternContext {
  public:
    IdentifierPatternContext(PatternContext *ctx);

    IdentifierContext *identifier();
    virtual size_t getContextId() const override;
  };

  virtual PatternContext* pattern();

  class  AssignmentPatternContext : public antlr4::ParserRuleContext {
  public:
    CppString type;
    FormalParser::PatternContext *left_ = nullptr;;
    FormalParser::ExpressionContext *right_ = nullptr;;
    AssignmentPatternContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    virtual size_t getContextId() const override;
    AssignmentOperatorContext *assignmentOperator();
    PatternContext *pattern();
    ExpressionContext *expression();

   
  };

  virtual AssignmentPatternContext* assignmentPattern();

  class  InitializerContext : public antlr4::ParserRuleContext {
  public:
    FormalParser::ExpressionContext *expression_ = nullptr;;
    InitializerContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    virtual size_t getContextId() const override;
    antlr4::tree::TerminalNode *Assign();
    ExpressionContext *expression();

   
  };

  virtual InitializerContext* initializer();

  class  ParameterListContext : public antlr4::ParserRuleContext {
  public:
    boolean isArrayList;
    ParameterListContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    virtual size_t getContextId() const override;
    std::vector<ParameterContext *> parameter();
    ParameterContext* parameter(size_t i);
    std::vector<antlr4::tree::TerminalNode *> Comma();
    antlr4::tree::TerminalNode* Comma(size_t i);

   
  };

  virtual ParameterListContext* parameterList();

  class  ParameterContext : public antlr4::ParserRuleContext {
  public:
    ParameterContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    virtual size_t getContextId() const override;
    AssignmentPatternContext *assignmentPattern();
    PatternContext *pattern();

   
  };

  virtual ParameterContext* parameter();

  class  AdvancedParameterListContext : public antlr4::ParserRuleContext {
  public:
    boolean isArrayList;
    AdvancedParameterListContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    virtual size_t getContextId() const override;
    SpreadElementContext *spreadElement();
    std::vector<AdvancedParameterContext *> advancedParameter();
    AdvancedParameterContext* advancedParameter(size_t i);
    std::vector<antlr4::tree::TerminalNode *> Comma();
    antlr4::tree::TerminalNode* Comma(size_t i);

   
  };

  virtual AdvancedParameterListContext* advancedParameterList();

  class  RequiredParameterListContext : public antlr4::ParserRuleContext {
  public:
    RequiredParameterListContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    virtual size_t getContextId() const override;
    std::vector<RequiredParameterContext *> requiredParameter();
    RequiredParameterContext* requiredParameter(size_t i);
    std::vector<antlr4::tree::TerminalNode *> Comma();
    antlr4::tree::TerminalNode* Comma(size_t i);

   
  };

  virtual RequiredParameterListContext* requiredParameterList();

  class  AdvancedParameterContext : public antlr4::ParserRuleContext {
  public:
    AdvancedParameterContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    virtual size_t getContextId() const override;
    RequiredParameterContext *requiredParameter();
    OptionalParameterContext *optionalParameter();

   
  };

  virtual AdvancedParameterContext* advancedParameter();

  class  OptionalParameterContext : public antlr4::ParserRuleContext {
  public:
    FormalParser::PatternContext *id_ = nullptr;;
    FormalParser::InitializerContext *init_ = nullptr;;
    OptionalParameterContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    virtual size_t getContextId() const override;
    PatternContext *pattern();
    antlr4::tree::TerminalNode *QuestionMark();
    InitializerContext *initializer();

   
  };

  virtual OptionalParameterContext* optionalParameter();

  class  RequiredParameterContext : public antlr4::ParserRuleContext {
  public:
    FormalParser::PatternContext *id_ = nullptr;;
    FormalParser::TypeAnnotationContext *typeAnnotation_ = nullptr;;
    RequiredParameterContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    virtual size_t getContextId() const override;
    PatternContext *pattern();
    TypeAnnotationContext *typeAnnotation();

   
  };

  virtual RequiredParameterContext* requiredParameter();

  class  AccessibilityModifierContext : public antlr4::ParserRuleContext {
  public:
    CppString type;
    AccessibilityModifierContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    virtual size_t getContextId() const override;
    antlr4::tree::TerminalNode *Public();
    antlr4::tree::TerminalNode *Private();
    antlr4::tree::TerminalNode *Protected();

   
  };

  virtual AccessibilityModifierContext* accessibilityModifier();

  class  InterfaceExtendsClauseContext : public antlr4::ParserRuleContext {
  public:
    InterfaceExtendsClauseContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    virtual size_t getContextId() const override;
    antlr4::tree::TerminalNode *Extends();
    ClassOrInterfaceTypeListContext *classOrInterfaceTypeList();

   
  };

  virtual InterfaceExtendsClauseContext* interfaceExtendsClause();

  class  ClassOrInterfaceTypeListContext : public antlr4::ParserRuleContext {
  public:
    boolean isArrayList;
    ClassOrInterfaceTypeListContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    virtual size_t getContextId() const override;
    std::vector<TypeNameContext *> typeName();
    TypeNameContext* typeName(size_t i);
    std::vector<antlr4::tree::TerminalNode *> Comma();
    antlr4::tree::TerminalNode* Comma(size_t i);

   
  };

  virtual ClassOrInterfaceTypeListContext* classOrInterfaceTypeList();

  class  EnumDeclarationContext : public antlr4::ParserRuleContext {
  public:
    FormalParser::IdentifierContext *id_ = nullptr;;
    FormalParser::EnumBodyContext *body_ = nullptr;;
    EnumDeclarationContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    virtual size_t getContextId() const override;
    antlr4::tree::TerminalNode *Enum();
    antlr4::tree::TerminalNode *OpenBrace();
    antlr4::tree::TerminalNode *CloseBrace();
    IdentifierContext *identifier();
    antlr4::tree::TerminalNode *Const();
    EnumBodyContext *enumBody();

   
  };

  virtual EnumDeclarationContext* enumDeclaration();

  class  EnumBodyContext : public antlr4::ParserRuleContext {
  public:
    FormalParser::EnumMemberListContext *memberList_ = nullptr;;
    EnumBodyContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    virtual size_t getContextId() const override;
    EnumMemberListContext *enumMemberList();
    antlr4::tree::TerminalNode *Comma();

   
  };

  virtual EnumBodyContext* enumBody();

  class  EnumMemberListContext : public antlr4::ParserRuleContext {
  public:
    EnumMemberListContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    virtual size_t getContextId() const override;
    std::vector<EnumMemberContext *> enumMember();
    EnumMemberContext* enumMember(size_t i);
    std::vector<antlr4::tree::TerminalNode *> Comma();
    antlr4::tree::TerminalNode* Comma(size_t i);

   
  };

  virtual EnumMemberListContext* enumMemberList();

  class  EnumMemberContext : public antlr4::ParserRuleContext {
  public:
    EnumMemberContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    virtual size_t getContextId() const override;
    PropertyNameContext *propertyName();
    antlr4::tree::TerminalNode *Assign();
    ExpressionContext *expression();

   
  };

  virtual EnumMemberContext* enumMember();

  class  ImportAliasDeclarationContext : public antlr4::ParserRuleContext {
  public:
    FormalParser::IdentifierContext *id_ = nullptr;;
    FormalParser::QualifiedNameContext *namespaceName_ = nullptr;;
    ImportAliasDeclarationContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    virtual size_t getContextId() const override;
    antlr4::tree::TerminalNode *Assign();
    antlr4::tree::TerminalNode *SemiColon();
    IdentifierContext *identifier();
    QualifiedNameContext *qualifiedName();

   
  };

  virtual ImportAliasDeclarationContext* importAliasDeclaration();

  class  ProgramContext : public antlr4::ParserRuleContext {
  public:
    CppString type;
    CppString sourceType;
    FormalParser::SourceArrayListContext *body_ = nullptr;;
    ProgramContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    virtual size_t getContextId() const override;
    antlr4::tree::TerminalNode *EOF();
    SourceArrayListContext *sourceArrayList();

   
  };

  virtual ProgramContext* program();

  class  SourceElementContext : public antlr4::ParserRuleContext {
  public:
    FormalParser::StatementContext *statement_ = nullptr;;
    SourceElementContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    virtual size_t getContextId() const override;
    StatementContext *statement();
    antlr4::tree::TerminalNode *Export();

   
  };

  virtual SourceElementContext* sourceElement();

  class  StatementContext : public antlr4::ParserRuleContext {
  public:
    CppString type;
    StatementContext(antlr4::ParserRuleContext *parent, size_t invokingState);
   
    StatementContext() = default;
    void copyFrom(StatementContext *context);
    using antlr4::ParserRuleContext::copyFrom;

    virtual size_t getRuleIndex() const override;
    virtual size_t getContextId() const override;

   
  };

  class  ExportStatementContext : public StatementContext {
  public:
    ExportStatementContext(StatementContext *ctx);

    antlr4::tree::TerminalNode *Export();
    FromBlockContext *fromBlock();
    StatementContext *statement();
    antlr4::tree::TerminalNode *Default();
    virtual size_t getContextId() const override;
  };

  class  TSEnumDeclarationContext : public StatementContext {
  public:
    TSEnumDeclarationContext(StatementContext *ctx);

    EnumDeclarationContext *enumDeclaration();
    virtual size_t getContextId() const override;
  };

  class  EmptyStatementContext : public StatementContext {
  public:
    EmptyStatementContext(StatementContext *ctx);

    antlr4::tree::TerminalNode *SemiColon();
    virtual size_t getContextId() const override;
  };

  class  BlockStatementContext : public StatementContext {
  public:
    BlockStatementContext(StatementContext *ctx);

    BraceBlockContext *braceBlock();
    virtual size_t getContextId() const override;
  };

  class  ImportStatementContext : public StatementContext {
  public:
    ImportStatementContext(StatementContext *ctx);

    antlr4::tree::TerminalNode *Import();
    FromBlockContext *fromBlock();
    ImportAliasDeclarationContext *importAliasDeclaration();
    virtual size_t getContextId() const override;
  };

  class  WhileStatementContext : public StatementContext {
  public:
    WhileStatementContext(StatementContext *ctx);

    FormalParser::ExpressionSequenceContext *test_ = nullptr;
    FormalParser::StatementContext *body_ = nullptr;
    antlr4::tree::TerminalNode *While();
    antlr4::tree::TerminalNode *OpenParen();
    antlr4::tree::TerminalNode *CloseParen();
    ExpressionSequenceContext *expressionSequence();
    StatementContext *statement();
    virtual size_t getContextId() const override;
  };

  class  WithStatementContext : public StatementContext {
  public:
    WithStatementContext(StatementContext *ctx);

    FormalParser::ExpressionSequenceContext *object_ = nullptr;
    FormalParser::StatementContext *body_ = nullptr;
    antlr4::tree::TerminalNode *With();
    antlr4::tree::TerminalNode *OpenParen();
    antlr4::tree::TerminalNode *CloseParen();
    ExpressionSequenceContext *expressionSequence();
    StatementContext *statement();
    virtual size_t getContextId() const override;
  };

  class  BreakStatementContext : public StatementContext {
  public:
    BreakStatementContext(StatementContext *ctx);

    FormalParser::IdentifierContext *label_ = nullptr;
    antlr4::tree::TerminalNode *Break();
    EosContext *eos();
    IdentifierContext *identifier();
    virtual size_t getContextId() const override;
  };

  class  IfStatementContext : public StatementContext {
  public:
    IfStatementContext(StatementContext *ctx);

    FormalParser::ExpressionSequenceContext *test_ = nullptr;
    FormalParser::StatementContext *consequent_ = nullptr;
    FormalParser::StatementContext *alternate = nullptr;
    antlr4::tree::TerminalNode *If();
    antlr4::tree::TerminalNode *OpenParen();
    antlr4::tree::TerminalNode *CloseParen();
    ExpressionSequenceContext *expressionSequence();
    std::vector<StatementContext *> statement();
    StatementContext* statement(size_t i);
    antlr4::tree::TerminalNode *Else();
    virtual size_t getContextId() const override;
  };

  class  SwitchStatementContext : public StatementContext {
  public:
    SwitchStatementContext(StatementContext *ctx);

    FormalParser::ExpressionSequenceContext *discriminant_ = nullptr;
    FormalParser::SwitchCaseListContext *cases_ = nullptr;
    antlr4::tree::TerminalNode *Switch();
    antlr4::tree::TerminalNode *OpenParen();
    antlr4::tree::TerminalNode *CloseParen();
    ExpressionSequenceContext *expressionSequence();
    SwitchCaseListContext *switchCaseList();
    virtual size_t getContextId() const override;
  };

  class  TSModuleDeclarationContext : public StatementContext {
  public:
    TSModuleDeclarationContext(StatementContext *ctx);

    FormalParser::StatementListContext *body_ = nullptr;
    antlr4::tree::TerminalNode *Namespace();
    antlr4::tree::TerminalNode *OpenBrace();
    antlr4::tree::TerminalNode *CloseBrace();
    IdentifierContext *identifier();
    QualifiedNameContext *qualifiedName();
    StatementListContext *statementList();
    virtual size_t getContextId() const override;
  };

  class  LabeledStatementContext : public StatementContext {
  public:
    LabeledStatementContext(StatementContext *ctx);

    FormalParser::IdentifierContext *label_ = nullptr;
    FormalParser::StatementContext *body_ = nullptr;
    antlr4::tree::TerminalNode *Colon();
    IdentifierContext *identifier();
    StatementContext *statement();
    virtual size_t getContextId() const override;
  };

  class  TryStatementContext : public StatementContext {
  public:
    TryStatementContext(StatementContext *ctx);

    FormalParser::BraceBlockContext *block_ = nullptr;
    FormalParser::CatchProductionContext *handler_ = nullptr;
    FormalParser::FinallyProductionContext *finalizer_ = nullptr;
    antlr4::tree::TerminalNode *Try();
    BraceBlockContext *braceBlock();
    CatchProductionContext *catchProduction();
    FinallyProductionContext *finallyProduction();
    virtual size_t getContextId() const override;
  };

  class  ExpressionStatementContext : public StatementContext {
  public:
    ExpressionStatementContext(StatementContext *ctx);

    FormalParser::ExpressionSequenceContext *expression_ = nullptr;
    ExpressionSequenceContext *expressionSequence();
    antlr4::tree::TerminalNode *SemiColon();
    virtual size_t getContextId() const override;
  };

  class  ReturnStatementContext : public StatementContext {
  public:
    ReturnStatementContext(StatementContext *ctx);

    FormalParser::ExpressionContext *argument_ = nullptr;
    antlr4::tree::TerminalNode *Return();
    EosContext *eos();
    ExpressionContext *expression();
    virtual size_t getContextId() const override;
  };

  class  ThrowStatementContext : public StatementContext {
  public:
    ThrowStatementContext(StatementContext *ctx);

    FormalParser::ExpressionSequenceContext *argument_ = nullptr;
    antlr4::tree::TerminalNode *Throw();
    EosContext *eos();
    ExpressionSequenceContext *expressionSequence();
    virtual size_t getContextId() const override;
  };

  class  TSTypeAliasDeclarationContext : public StatementContext {
  public:
    TSTypeAliasDeclarationContext(StatementContext *ctx);

    FormalParser::IdentifierContext *alias_ = nullptr;
    FormalParser::Type_Context *original_ = nullptr;
    antlr4::tree::TerminalNode *TypeAlias();
    antlr4::tree::TerminalNode *Assign();
    EosContext *eos();
    IdentifierContext *identifier();
    Type_Context *type_();
    virtual size_t getContextId() const override;
  };

  class  ForStatementContext : public StatementContext {
  public:
    ForStatementContext(StatementContext *ctx);

    FormalParser::ForInitStatementContext *init_ = nullptr;
    FormalParser::ExpressionSequenceContext *test_ = nullptr;
    FormalParser::ExpressionSequenceContext *update_ = nullptr;
    FormalParser::StatementContext *body_ = nullptr;
    antlr4::tree::TerminalNode *For();
    antlr4::tree::TerminalNode *OpenParen();
    std::vector<antlr4::tree::TerminalNode *> SemiColon();
    antlr4::tree::TerminalNode* SemiColon(size_t i);
    antlr4::tree::TerminalNode *CloseParen();
    StatementContext *statement();
    ForInitStatementContext *forInitStatement();
    std::vector<ExpressionSequenceContext *> expressionSequence();
    ExpressionSequenceContext* expressionSequence(size_t i);
    virtual size_t getContextId() const override;
  };

  class  DoWhileStatementContext : public StatementContext {
  public:
    DoWhileStatementContext(StatementContext *ctx);

    FormalParser::StatementContext *body_ = nullptr;
    FormalParser::ExpressionSequenceContext *test_ = nullptr;
    antlr4::tree::TerminalNode *Do();
    antlr4::tree::TerminalNode *While();
    antlr4::tree::TerminalNode *OpenParen();
    antlr4::tree::TerminalNode *CloseParen();
    EosContext *eos();
    StatementContext *statement();
    ExpressionSequenceContext *expressionSequence();
    virtual size_t getContextId() const override;
  };

  class  ForInStatementContext : public StatementContext {
  public:
    ForInStatementContext(StatementContext *ctx);

    FormalParser::BaseForXStatementContext *left_ = nullptr;
    FormalParser::ExpressionSequenceContext *right_ = nullptr;
    FormalParser::StatementContext *body_ = nullptr;
    antlr4::tree::TerminalNode *For();
    antlr4::tree::TerminalNode *OpenParen();
    antlr4::tree::TerminalNode *In();
    antlr4::tree::TerminalNode *CloseParen();
    BaseForXStatementContext *baseForXStatement();
    ExpressionSequenceContext *expressionSequence();
    StatementContext *statement();
    virtual size_t getContextId() const override;
  };

  class  ContinueStatementContext : public StatementContext {
  public:
    ContinueStatementContext(StatementContext *ctx);

    FormalParser::IdentifierContext *label_ = nullptr;
    antlr4::tree::TerminalNode *Continue();
    EosContext *eos();
    IdentifierContext *identifier();
    virtual size_t getContextId() const override;
  };

  class  DebuggerStatementContext : public StatementContext {
  public:
    DebuggerStatementContext(StatementContext *ctx);

    antlr4::tree::TerminalNode *Debugger();
    EosContext *eos();
    virtual size_t getContextId() const override;
  };

  class  ForOfStatementContext : public StatementContext {
  public:
    ForOfStatementContext(StatementContext *ctx);

    FormalParser::BaseForXStatementContext *left_ = nullptr;
    FormalParser::ExpressionSequenceContext *right_ = nullptr;
    FormalParser::StatementContext *body_ = nullptr;
    antlr4::tree::TerminalNode *For();
    antlr4::tree::TerminalNode *OpenParen();
    antlr4::tree::TerminalNode *Of();
    antlr4::tree::TerminalNode *CloseParen();
    BaseForXStatementContext *baseForXStatement();
    ExpressionSequenceContext *expressionSequence();
    StatementContext *statement();
    virtual size_t getContextId() const override;
  };

  class  DeclarationStatementContext : public StatementContext {
  public:
    DeclarationStatementContext(StatementContext *ctx);

    DeclarationContext *declaration();
    virtual size_t getContextId() const override;
  };

  virtual StatementContext* statement();

  class  BraceBlockContext : public antlr4::ParserRuleContext {
  public:
    CppString type;
    FormalParser::StatementListContext *body_ = nullptr;;
    BraceBlockContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    virtual size_t getContextId() const override;
    antlr4::tree::TerminalNode *OpenBrace();
    antlr4::tree::TerminalNode *CloseBrace();
    StatementListContext *statementList();

   
  };

  virtual BraceBlockContext* braceBlock();

  class  DeclarationContext : public antlr4::ParserRuleContext {
  public:
    DeclarationContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    virtual size_t getContextId() const override;
    FunctionDeclarationContext *functionDeclaration();
    VariableDeclarationContext *variableDeclaration();
    EosContext *eos();
    BaseClassContext *baseClass();

   
  };

  virtual DeclarationContext* declaration();

  class  FunctionDeclarationContext : public antlr4::ParserRuleContext {
  public:
    CppString type;
    FormalParser::BaseFunctionContext *baseFunction_ = nullptr;;
    FormalParser::BraceBlockContext *body_ = nullptr;;
    FunctionDeclarationContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    virtual size_t getContextId() const override;
    BaseFunctionContext *baseFunction();
    antlr4::tree::TerminalNode *SemiColon();
    BraceBlockContext *braceBlock();

   
  };

  virtual FunctionDeclarationContext* functionDeclaration();

  class  BaseFunctionContext : public antlr4::ParserRuleContext {
  public:
    boolean async_;
    boolean generator_;
    FormalParser::IdentifierContext *id_ = nullptr;;
    FormalParser::ParameterListContext *params_ = nullptr;;
    FormalParser::FunctionReturnTypeContext *typeAnnotation_ = nullptr;;
    BaseFunctionContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    virtual size_t getContextId() const override;
    antlr4::tree::TerminalNode *Function_();
    antlr4::tree::TerminalNode *OpenParen();
    antlr4::tree::TerminalNode *CloseParen();
    antlr4::tree::TerminalNode *Async();
    antlr4::tree::TerminalNode *Multiply();
    antlr4::tree::TerminalNode *Colon();
    IdentifierContext *identifier();
    ParameterListContext *parameterList();
    FunctionReturnTypeContext *functionReturnType();

   
  };

  virtual BaseFunctionContext* baseFunction();

  class  BaseClassContext : public antlr4::ParserRuleContext {
  public:
    CppString type;
    FormalParser::IdentifierContext *id_ = nullptr;;
    FormalParser::ClassExtendsClauseContext *superClass_ = nullptr;;
    FormalParser::ImplementsClauseContext *implements_ = nullptr;;
    FormalParser::ClassBodyContext *body_ = nullptr;;
    BaseClassContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    virtual size_t getContextId() const override;
    antlr4::tree::TerminalNode *Class();
    ClassBodyContext *classBody();
    antlr4::tree::TerminalNode *Declare();
    antlr4::tree::TerminalNode *Abstract();
    IdentifierContext *identifier();
    ClassExtendsClauseContext *classExtendsClause();
    ImplementsClauseContext *implementsClause();

   
  };

  virtual BaseClassContext* baseClass();

  class  StatementListContext : public antlr4::ParserRuleContext {
  public:
    boolean isArrayList;
    StatementListContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    virtual size_t getContextId() const override;
    std::vector<StatementContext *> statement();
    StatementContext* statement(size_t i);

   
  };

  virtual StatementListContext* statementList();

  class  FromBlockContext : public antlr4::ParserRuleContext {
  public:
    FormalParser::MultipleImportStatementContext *multipleImportStatement_ = nullptr;;
    FormalParser::IdentifierContext *id_ = nullptr;;
    FromBlockContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    virtual size_t getContextId() const override;
    antlr4::tree::TerminalNode *From();
    antlr4::tree::TerminalNode *StringLiteral();
    EosContext *eos();
    antlr4::tree::TerminalNode *Multiply();
    MultipleImportStatementContext *multipleImportStatement();
    antlr4::tree::TerminalNode *As();
    IdentifierContext *identifier();

   
  };

  virtual FromBlockContext* fromBlock();

  class  MultipleImportStatementContext : public antlr4::ParserRuleContext {
  public:
    MultipleImportStatementContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    virtual size_t getContextId() const override;
    antlr4::tree::TerminalNode *OpenBrace();
    std::vector<IdentifierContext *> identifier();
    IdentifierContext* identifier(size_t i);
    antlr4::tree::TerminalNode *CloseBrace();
    std::vector<antlr4::tree::TerminalNode *> Comma();
    antlr4::tree::TerminalNode* Comma(size_t i);

   
  };

  virtual MultipleImportStatementContext* multipleImportStatement();

  class  VariableDeclarationContext : public antlr4::ParserRuleContext {
  public:
    CppString type;
    FormalParser::VarModifierContext *kind_ = nullptr;;
    FormalParser::VariableDeclaratorListContext *declarations_ = nullptr;;
    antlr4::Token *letToken = nullptr;;
    VariableDeclarationContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    virtual size_t getContextId() const override;
    VarModifierContext *varModifier();
    VariableDeclaratorListContext *variableDeclaratorList();
    antlr4::tree::TerminalNode *SemiColon();
    antlr4::tree::TerminalNode *Let();
    EosContext *eos();

   
  };

  virtual VariableDeclarationContext* variableDeclaration();

  class  VariableDeclaratorListContext : public antlr4::ParserRuleContext {
  public:
    boolean isArrayList;
    VariableDeclaratorListContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    virtual size_t getContextId() const override;
    std::vector<VariableDeclaratorContext *> variableDeclarator();
    VariableDeclaratorContext* variableDeclarator(size_t i);
    std::vector<antlr4::tree::TerminalNode *> Comma();
    antlr4::tree::TerminalNode* Comma(size_t i);

   
  };

  virtual VariableDeclaratorListContext* variableDeclaratorList();

  class  VariableDeclaratorContext : public antlr4::ParserRuleContext {
  public:
    CppString type;
    FormalParser::PatternContext *id_ = nullptr;;
    FormalParser::ExpressionContext *init_ = nullptr;;
    FormalParser::KeywordContext *keywordContext = nullptr;;
    VariableDeclaratorContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    virtual size_t getContextId() const override;
    PatternContext *pattern();
    antlr4::tree::TerminalNode *Assign();
    ExpressionContext *expression();
    KeywordContext *keyword();

   
  };

  virtual VariableDeclaratorContext* variableDeclarator();

  class  ForInitStatementContext : public antlr4::ParserRuleContext {
  public:
    ForInitStatementContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    virtual size_t getContextId() const override;
    VariableDeclarationContext *variableDeclaration();
    ExpressionContext *expression();

   
  };

  virtual ForInitStatementContext* forInitStatement();

  class  BaseForXStatementContext : public antlr4::ParserRuleContext {
  public:
    BaseForXStatementContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    virtual size_t getContextId() const override;
    VariableDeclarationContext *variableDeclaration();
    PatternContext *pattern();
    ExpressionContext *expression();

   
  };

  virtual BaseForXStatementContext* baseForXStatement();

  class  VarModifierContext : public antlr4::ParserRuleContext {
  public:
    VarModifierContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    virtual size_t getContextId() const override;
    antlr4::tree::TerminalNode *Var();
    antlr4::tree::TerminalNode *Let();
    antlr4::tree::TerminalNode *Const();

   
  };

  virtual VarModifierContext* varModifier();

  class  SwitchCaseListContext : public antlr4::ParserRuleContext {
  public:
    boolean isArrayList;
    SwitchCaseListContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    virtual size_t getContextId() const override;
    antlr4::tree::TerminalNode *OpenBrace();
    antlr4::tree::TerminalNode *CloseBrace();
    std::vector<CaseClausesContext *> caseClauses();
    CaseClausesContext* caseClauses(size_t i);
    DefaultClauseContext *defaultClause();

   
  };

  virtual SwitchCaseListContext* switchCaseList();

  class  CaseClausesContext : public antlr4::ParserRuleContext {
  public:
    CaseClausesContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    virtual size_t getContextId() const override;
    std::vector<CaseClauseContext *> caseClause();
    CaseClauseContext* caseClause(size_t i);

   
  };

  virtual CaseClausesContext* caseClauses();

  class  CaseClauseContext : public antlr4::ParserRuleContext {
  public:
    CppString type;
    FormalParser::ExpressionSequenceContext *test_ = nullptr;;
    FormalParser::StatementListContext *consequent_ = nullptr;;
    CaseClauseContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    virtual size_t getContextId() const override;
    antlr4::tree::TerminalNode *Case();
    antlr4::tree::TerminalNode *Colon();
    ExpressionSequenceContext *expressionSequence();
    StatementListContext *statementList();

   
  };

  virtual CaseClauseContext* caseClause();

  class  DefaultClauseContext : public antlr4::ParserRuleContext {
  public:
    CppString type;
    FormalParser::StatementListContext *consequent_ = nullptr;;
    DefaultClauseContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    virtual size_t getContextId() const override;
    antlr4::tree::TerminalNode *Default();
    antlr4::tree::TerminalNode *Colon();
    StatementListContext *statementList();

   
  };

  virtual DefaultClauseContext* defaultClause();

  class  CatchProductionContext : public antlr4::ParserRuleContext {
  public:
    CppString type;
    FormalParser::IdentifierContext *param_ = nullptr;;
    FormalParser::BraceBlockContext *body_ = nullptr;;
    CatchProductionContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    virtual size_t getContextId() const override;
    antlr4::tree::TerminalNode *Catch();
    antlr4::tree::TerminalNode *OpenParen();
    antlr4::tree::TerminalNode *CloseParen();
    IdentifierContext *identifier();
    BraceBlockContext *braceBlock();

   
  };

  virtual CatchProductionContext* catchProduction();

  class  FinallyProductionContext : public antlr4::ParserRuleContext {
  public:
    FinallyProductionContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    virtual size_t getContextId() const override;
    antlr4::tree::TerminalNode *Finally();
    BraceBlockContext *braceBlock();

   
  };

  virtual FinallyProductionContext* finallyProduction();

  class  ClassBodyContext : public antlr4::ParserRuleContext {
  public:
    boolean isArrayList;
    ClassBodyContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    virtual size_t getContextId() const override;
    antlr4::tree::TerminalNode *OpenBrace();
    antlr4::tree::TerminalNode *CloseBrace();
    std::vector<ClassElementContext *> classElement();
    ClassElementContext* classElement(size_t i);

   
  };

  virtual ClassBodyContext* classBody();

  class  ClassExtendsClauseContext : public antlr4::ParserRuleContext {
  public:
    FormalParser::TypeNameContext *superClass_ = nullptr;;
    ClassExtendsClauseContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    virtual size_t getContextId() const override;
    antlr4::tree::TerminalNode *Extends();
    TypeNameContext *typeName();

   
  };

  virtual ClassExtendsClauseContext* classExtendsClause();

  class  ImplementsClauseContext : public antlr4::ParserRuleContext {
  public:
    FormalParser::ClassOrInterfaceTypeListContext *interfaces_ = nullptr;;
    ImplementsClauseContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    virtual size_t getContextId() const override;
    antlr4::tree::TerminalNode *Implements();
    ClassOrInterfaceTypeListContext *classOrInterfaceTypeList();

   
  };

  virtual ImplementsClauseContext* implementsClause();

  class  ClassElementContext : public antlr4::ParserRuleContext {
  public:
    ClassElementContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    virtual size_t getContextId() const override;
    MethodDefinitionContext *methodDefinition();
    PropertyDefinitionContext *propertyDefinition();

   
  };

  virtual ClassElementContext* classElement();

  class  MethodDefinitionContext : public antlr4::ParserRuleContext {
  public:
    CppString type;
    CppString kind;
    boolean computed;
    boolean static_;
    boolean async_;
    FormalParser::AccessibilityModifierContext *accessibility_ = nullptr;;
    FormalParser::PropertyNameContext *key_ = nullptr;;
    FormalParser::AdvancedParameterListContext *parameterList_ = nullptr;;
    FormalParser::BraceBlockContext *body_ = nullptr;;
    FormalParser::GetAccessorContext *getter_ = nullptr;;
    FormalParser::SetAccessorContext *setter_ = nullptr;;
    MethodDefinitionContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    virtual size_t getContextId() const override;
    antlr4::tree::TerminalNode *OpenParen();
    antlr4::tree::TerminalNode *CloseParen();
    PropertyNameContext *propertyName();
    antlr4::tree::TerminalNode *SemiColon();
    antlr4::tree::TerminalNode *Static();
    antlr4::tree::TerminalNode *Async();
    BraceBlockContext *braceBlock();
    AccessibilityModifierContext *accessibilityModifier();
    AdvancedParameterListContext *advancedParameterList();
    GetAccessorContext *getAccessor();
    SetAccessorContext *setAccessor();
    antlr4::tree::TerminalNode *Constructor();

   
  };

  virtual MethodDefinitionContext* methodDefinition();

  class  PropertyDefinitionContext : public antlr4::ParserRuleContext {
  public:
    CppString type;
    boolean computed;
    boolean static_;
    boolean async_;
    boolean readonly_;
    FormalParser::AccessibilityModifierContext *accessibility_ = nullptr;;
    FormalParser::PropertyNameContext *key_ = nullptr;;
    FormalParser::TypeAnnotationContext *typeAnnotation_ = nullptr;;
    FormalParser::ExpressionContext *value_ = nullptr;;
    PropertyDefinitionContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    virtual size_t getContextId() const override;
    antlr4::tree::TerminalNode *SemiColon();
    PropertyNameContext *propertyName();
    antlr4::tree::TerminalNode *Static();
    antlr4::tree::TerminalNode *ReadOnly();
    antlr4::tree::TerminalNode *QuestionMark();
    AccessibilityModifierContext *accessibilityModifier();
    TypeAnnotationContext *typeAnnotation();
    ExpressionContext *expression();

   
  };

  virtual PropertyDefinitionContext* propertyDefinition();

  class  GeneratorMethodContext : public antlr4::ParserRuleContext {
  public:
    GeneratorMethodContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    virtual size_t getContextId() const override;
    IdentifierContext *identifier();
    antlr4::tree::TerminalNode *OpenParen();
    antlr4::tree::TerminalNode *CloseParen();
    antlr4::tree::TerminalNode *OpenBrace();
    FunctionBodyContext *functionBody();
    antlr4::tree::TerminalNode *CloseBrace();
    antlr4::tree::TerminalNode *Multiply();
    ParameterListContext *parameterList();

   
  };

  virtual GeneratorMethodContext* generatorMethod();

  class  GeneratorFunctionDeclarationContext : public antlr4::ParserRuleContext {
  public:
    GeneratorFunctionDeclarationContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    virtual size_t getContextId() const override;
    antlr4::tree::TerminalNode *Function_();
    antlr4::tree::TerminalNode *Multiply();
    antlr4::tree::TerminalNode *OpenParen();
    antlr4::tree::TerminalNode *CloseParen();
    antlr4::tree::TerminalNode *OpenBrace();
    FunctionBodyContext *functionBody();
    antlr4::tree::TerminalNode *CloseBrace();
    IdentifierContext *identifier();
    ParameterListContext *parameterList();

   
  };

  virtual GeneratorFunctionDeclarationContext* generatorFunctionDeclaration();

  class  GeneratorBlockContext : public antlr4::ParserRuleContext {
  public:
    GeneratorBlockContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    virtual size_t getContextId() const override;
    antlr4::tree::TerminalNode *OpenBrace();
    std::vector<GeneratorDefinitionContext *> generatorDefinition();
    GeneratorDefinitionContext* generatorDefinition(size_t i);
    antlr4::tree::TerminalNode *CloseBrace();
    std::vector<antlr4::tree::TerminalNode *> Comma();
    antlr4::tree::TerminalNode* Comma(size_t i);

   
  };

  virtual GeneratorBlockContext* generatorBlock();

  class  GeneratorDefinitionContext : public antlr4::ParserRuleContext {
  public:
    GeneratorDefinitionContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    virtual size_t getContextId() const override;
    antlr4::tree::TerminalNode *Multiply();
    IteratorDefinitionContext *iteratorDefinition();

   
  };

  virtual GeneratorDefinitionContext* generatorDefinition();

  class  IteratorBlockContext : public antlr4::ParserRuleContext {
  public:
    IteratorBlockContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    virtual size_t getContextId() const override;
    antlr4::tree::TerminalNode *OpenBrace();
    std::vector<IteratorDefinitionContext *> iteratorDefinition();
    IteratorDefinitionContext* iteratorDefinition(size_t i);
    antlr4::tree::TerminalNode *CloseBrace();
    std::vector<antlr4::tree::TerminalNode *> Comma();
    antlr4::tree::TerminalNode* Comma(size_t i);

   
  };

  virtual IteratorBlockContext* iteratorBlock();

  class  IteratorDefinitionContext : public antlr4::ParserRuleContext {
  public:
    IteratorDefinitionContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    virtual size_t getContextId() const override;
    antlr4::tree::TerminalNode *OpenBracket();
    ExpressionContext *expression();
    antlr4::tree::TerminalNode *CloseBracket();
    antlr4::tree::TerminalNode *OpenParen();
    antlr4::tree::TerminalNode *CloseParen();
    antlr4::tree::TerminalNode *OpenBrace();
    FunctionBodyContext *functionBody();
    antlr4::tree::TerminalNode *CloseBrace();
    ParameterListContext *parameterList();

   
  };

  virtual IteratorDefinitionContext* iteratorDefinition();

  class  FunctionBodyContext : public antlr4::ParserRuleContext {
  public:
    FunctionBodyContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    virtual size_t getContextId() const override;
    SourceArrayListContext *sourceArrayList();

   
  };

  virtual FunctionBodyContext* functionBody();

  class  SourceArrayListContext : public antlr4::ParserRuleContext {
  public:
    boolean isArrayList;
    SourceArrayListContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    virtual size_t getContextId() const override;
    std::vector<SourceElementContext *> sourceElement();
    SourceElementContext* sourceElement(size_t i);

   
  };

  virtual SourceArrayListContext* sourceArrayList();

  class  SpreadElementContext : public antlr4::ParserRuleContext {
  public:
    CppString type;
    FormalParser::ExpressionContext *argument_ = nullptr;;
    SpreadElementContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    virtual size_t getContextId() const override;
    antlr4::tree::TerminalNode *Ellipsis();
    ExpressionContext *expression();

   
  };

  virtual SpreadElementContext* spreadElement();

  class  ArrayElementContext : public antlr4::ParserRuleContext {
  public:
    ArrayElementContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    virtual size_t getContextId() const override;
    SpreadElementContext *spreadElement();
    ExpressionContext *expression();

   
  };

  virtual ArrayElementContext* arrayElement();

  class  ArrayElementArrayListContext : public antlr4::ParserRuleContext {
  public:
    boolean isArrayList;
    ArrayElementArrayListContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    virtual size_t getContextId() const override;
    std::vector<ArrayElementContext *> arrayElement();
    ArrayElementContext* arrayElement(size_t i);
    std::vector<antlr4::tree::TerminalNode *> Comma();
    antlr4::tree::TerminalNode* Comma(size_t i);

   
  };

  virtual ArrayElementArrayListContext* arrayElementArrayList();

  class  ArrayPatternElementArrayListContext : public antlr4::ParserRuleContext {
  public:
    boolean isArrayList;
    ArrayPatternElementArrayListContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    virtual size_t getContextId() const override;
    std::vector<PatternContext *> pattern();
    PatternContext* pattern(size_t i);
    std::vector<AssignmentPatternContext *> assignmentPattern();
    AssignmentPatternContext* assignmentPattern(size_t i);
    std::vector<antlr4::tree::TerminalNode *> Comma();
    antlr4::tree::TerminalNode* Comma(size_t i);

   
  };

  virtual ArrayPatternElementArrayListContext* arrayPatternElementArrayList();

  class  ObjectElementContext : public antlr4::ParserRuleContext {
  public:
    ObjectElementContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    virtual size_t getContextId() const override;
    PropertyContext *property();
    SpreadElementContext *spreadElement();

   
  };

  virtual ObjectElementContext* objectElement();

  class  ObjectElementArrayListContext : public antlr4::ParserRuleContext {
  public:
    boolean isArrayList;
    ObjectElementArrayListContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    virtual size_t getContextId() const override;
    std::vector<ObjectElementContext *> objectElement();
    ObjectElementContext* objectElement(size_t i);
    std::vector<antlr4::tree::TerminalNode *> Comma();
    antlr4::tree::TerminalNode* Comma(size_t i);

   
  };

  virtual ObjectElementArrayListContext* objectElementArrayList();

  class  PropertyNameContext : public antlr4::ParserRuleContext {
  public:
    boolean computed;
    PropertyNameContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    virtual size_t getContextId() const override;
    IdentifierContext *identifier();
    antlr4::tree::TerminalNode *StringLiteral();
    NumericLiteralContext *numericLiteral();
    PrivateIdentifierContext *privateIdentifier();

   
  };

  virtual PropertyNameContext* propertyName();

  class  PropertyKeyContext : public antlr4::ParserRuleContext {
  public:
    PropertyKeyContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    virtual size_t getContextId() const override;
    ExpressionContext *expression();
    PrivateIdentifierContext *privateIdentifier();

   
  };

  virtual PropertyKeyContext* propertyKey();

  class  PropertyContext : public antlr4::ParserRuleContext {
  public:
    CppString type;
    boolean method;
    boolean shorthand;
    boolean computed;
    CppString kind;
    PropertyContext(antlr4::ParserRuleContext *parent, size_t invokingState);
   
    PropertyContext() = default;
    void copyFrom(PropertyContext *context);
    using antlr4::ParserRuleContext::copyFrom;

    virtual size_t getRuleIndex() const override;
    virtual size_t getContextId() const override;

   
  };

  class  PropertyExpressionAssignmentContext : public PropertyContext {
  public:
    PropertyExpressionAssignmentContext(PropertyContext *ctx);

    FormalParser::PropertyKeyContext *key_ = nullptr;
    FormalParser::ExpressionContext *value_ = nullptr;
    antlr4::tree::TerminalNode *Colon();
    PropertyKeyContext *propertyKey();
    ExpressionContext *expression();
    virtual size_t getContextId() const override;
  };

  class  ComputedPropertyExpressionAssignmentContext : public PropertyContext {
  public:
    ComputedPropertyExpressionAssignmentContext(PropertyContext *ctx);

    FormalParser::ExpressionContext *key_ = nullptr;
    FormalParser::ExpressionContext *value_ = nullptr;
    antlr4::tree::TerminalNode *OpenBracket();
    antlr4::tree::TerminalNode *CloseBracket();
    antlr4::tree::TerminalNode *Colon();
    std::vector<ExpressionContext *> expression();
    ExpressionContext* expression(size_t i);
    virtual size_t getContextId() const override;
  };

  class  PropertyShorthandContext : public PropertyContext {
  public:
    PropertyShorthandContext(PropertyContext *ctx);

    FormalParser::PropertyKeyContext *key_ = nullptr;
    PropertyKeyContext *propertyKey();
    virtual size_t getContextId() const override;
  };

  class  PropertySetterContext : public PropertyContext {
  public:
    PropertySetterContext(PropertyContext *ctx);

    SetAccessorContext *setAccessor();
    virtual size_t getContextId() const override;
  };

  class  PropertyGetterContext : public PropertyContext {
  public:
    PropertyGetterContext(PropertyContext *ctx);

    GetAccessorContext *getAccessor();
    virtual size_t getContextId() const override;
  };

  class  MethodPropertyContext : public PropertyContext {
  public:
    MethodPropertyContext(PropertyContext *ctx);

    GeneratorMethodContext *generatorMethod();
    virtual size_t getContextId() const override;
  };

  virtual PropertyContext* property();

  class  AssignmentPropertyContext : public antlr4::ParserRuleContext {
  public:
    CppString type;
    boolean method;
    boolean shorthand;
    boolean computed;
    CppString kind;
    AssignmentPropertyContext(antlr4::ParserRuleContext *parent, size_t invokingState);
   
    AssignmentPropertyContext() = default;
    void copyFrom(AssignmentPropertyContext *context);
    using antlr4::ParserRuleContext::copyFrom;

    virtual size_t getRuleIndex() const override;
    virtual size_t getContextId() const override;

   
  };

  class  ShorthandAssignmentPropertyContext : public AssignmentPropertyContext {
  public:
    ShorthandAssignmentPropertyContext(AssignmentPropertyContext *ctx);

    FormalParser::PropertyKeyContext *key_ = nullptr;
    PropertyKeyContext *propertyKey();
    virtual size_t getContextId() const override;
  };

  class  AssignmentPatternInObjectContext : public AssignmentPropertyContext {
  public:
    AssignmentPatternInObjectContext(AssignmentPropertyContext *ctx);

    FormalParser::AssignmentPatternContext *value_ = nullptr;
    AssignmentPatternContext *assignmentPattern();
    virtual size_t getContextId() const override;
  };

  virtual AssignmentPropertyContext* assignmentProperty();

  class  ObjectPatternElementContext : public antlr4::ParserRuleContext {
  public:
    ObjectPatternElementContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    virtual size_t getContextId() const override;
    AssignmentPropertyContext *assignmentProperty();
    SpreadElementContext *spreadElement();

   
  };

  virtual ObjectPatternElementContext* objectPatternElement();

  class  ObjectPatternElementArrayListContext : public antlr4::ParserRuleContext {
  public:
    boolean isArrayList;
    ObjectPatternElementArrayListContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    virtual size_t getContextId() const override;
    std::vector<ObjectPatternElementContext *> objectPatternElement();
    ObjectPatternElementContext* objectPatternElement(size_t i);
    std::vector<antlr4::tree::TerminalNode *> Comma();
    antlr4::tree::TerminalNode* Comma(size_t i);

   
  };

  virtual ObjectPatternElementArrayListContext* objectPatternElementArrayList();

  class  GetAccessorContext : public antlr4::ParserRuleContext {
  public:
    FormalParser::GetterContext *getter_ = nullptr;;
    FormalParser::TypeAnnotationContext *typeAnnotation_ = nullptr;;
    FormalParser::FunctionBodyContext *body_ = nullptr;;
    GetAccessorContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    virtual size_t getContextId() const override;
    antlr4::tree::TerminalNode *OpenParen();
    antlr4::tree::TerminalNode *CloseParen();
    antlr4::tree::TerminalNode *OpenBrace();
    antlr4::tree::TerminalNode *CloseBrace();
    GetterContext *getter();
    FunctionBodyContext *functionBody();
    TypeAnnotationContext *typeAnnotation();

   
  };

  virtual GetAccessorContext* getAccessor();

  class  SetAccessorContext : public antlr4::ParserRuleContext {
  public:
    FormalParser::SetterContext *setter_ = nullptr;;
    FormalParser::IdentifierContext *id_ = nullptr;;
    FormalParser::PatternContext *pattern_ = nullptr;;
    FormalParser::TypeAnnotationContext *typeAnnotation_ = nullptr;;
    FormalParser::FunctionBodyContext *body_ = nullptr;;
    SetAccessorContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    virtual size_t getContextId() const override;
    antlr4::tree::TerminalNode *OpenParen();
    antlr4::tree::TerminalNode *CloseParen();
    antlr4::tree::TerminalNode *OpenBrace();
    antlr4::tree::TerminalNode *CloseBrace();
    SetterContext *setter();
    FunctionBodyContext *functionBody();
    IdentifierContext *identifier();
    PatternContext *pattern();
    TypeAnnotationContext *typeAnnotation();

   
  };

  virtual SetAccessorContext* setAccessor();

  class  ArgumentArrayListContext : public antlr4::ParserRuleContext {
  public:
    boolean isArrayList;
    ArgumentArrayListContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    virtual size_t getContextId() const override;
    std::vector<ArgumentContext *> argument();
    ArgumentContext* argument(size_t i);
    std::vector<antlr4::tree::TerminalNode *> Comma();
    antlr4::tree::TerminalNode* Comma(size_t i);

   
  };

  virtual ArgumentArrayListContext* argumentArrayList();

  class  ArgumentContext : public antlr4::ParserRuleContext {
  public:
    ArgumentContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    virtual size_t getContextId() const override;
    SpreadElementContext *spreadElement();
    ExpressionContext *expression();

   
  };

  virtual ArgumentContext* argument();

  class  ExpressionSequenceContext : public antlr4::ParserRuleContext {
  public:
    CppString type;
    ExpressionSequenceContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    virtual size_t getContextId() const override;
    std::vector<ExpressionContext *> expression();
    ExpressionContext* expression(size_t i);
    std::vector<antlr4::tree::TerminalNode *> Comma();
    antlr4::tree::TerminalNode* Comma(size_t i);

   
  };

  virtual ExpressionSequenceContext* expressionSequence();

  class  UpdateOperatorContext : public antlr4::ParserRuleContext {
  public:
    CppString type;
    boolean prefix;
    UpdateOperatorContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    virtual size_t getContextId() const override;
    antlr4::tree::TerminalNode *PlusPlus();
    antlr4::tree::TerminalNode *MinusMinus();

   
  };

  virtual UpdateOperatorContext* updateOperator();

  class  UnaryOperatorContext : public antlr4::ParserRuleContext {
  public:
    CppString type;
    boolean prefix;
    UnaryOperatorContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    virtual size_t getContextId() const override;
    antlr4::tree::TerminalNode *Minus();
    antlr4::tree::TerminalNode *Plus();
    antlr4::tree::TerminalNode *Not();
    antlr4::tree::TerminalNode *BitNot();
    antlr4::tree::TerminalNode *Typeof();
    antlr4::tree::TerminalNode *Void();
    antlr4::tree::TerminalNode *Delete();

   
  };

  virtual UnaryOperatorContext* unaryOperator();

  class  ExponentiationOperatorContext : public antlr4::ParserRuleContext {
  public:
    ExponentiationOperatorContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    virtual size_t getContextId() const override;
    antlr4::tree::TerminalNode *Exponentiation();

   
  };

  virtual ExponentiationOperatorContext* exponentiationOperator();

  class  MultiplicativeOperatorContext : public antlr4::ParserRuleContext {
  public:
    MultiplicativeOperatorContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    virtual size_t getContextId() const override;
    antlr4::tree::TerminalNode *Multiply();
    antlr4::tree::TerminalNode *Divide();
    antlr4::tree::TerminalNode *Modulus();

   
  };

  virtual MultiplicativeOperatorContext* multiplicativeOperator();

  class  AdditiveOperatorContext : public antlr4::ParserRuleContext {
  public:
    AdditiveOperatorContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    virtual size_t getContextId() const override;
    antlr4::tree::TerminalNode *Plus();
    antlr4::tree::TerminalNode *Minus();

   
  };

  virtual AdditiveOperatorContext* additiveOperator();

  class  BitShiftOperatorContext : public antlr4::ParserRuleContext {
  public:
    BitShiftOperatorContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    virtual size_t getContextId() const override;
    antlr4::tree::TerminalNode *LeftShiftArithmetic();
    antlr4::tree::TerminalNode *RightShiftArithmetic();
    antlr4::tree::TerminalNode *RightShiftLogical();

   
  };

  virtual BitShiftOperatorContext* bitShiftOperator();

  class  RelationalOperatorContext : public antlr4::ParserRuleContext {
  public:
    RelationalOperatorContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    virtual size_t getContextId() const override;
    antlr4::tree::TerminalNode *LessThan();
    antlr4::tree::TerminalNode *MoreThan();
    antlr4::tree::TerminalNode *LessThanEquals();
    antlr4::tree::TerminalNode *GreaterThanEquals();

   
  };

  virtual RelationalOperatorContext* relationalOperator();

  class  InstanceofOperatorContext : public antlr4::ParserRuleContext {
  public:
    InstanceofOperatorContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    virtual size_t getContextId() const override;
    antlr4::tree::TerminalNode *Instanceof();

   
  };

  virtual InstanceofOperatorContext* instanceofOperator();

  class  InOperatorContext : public antlr4::ParserRuleContext {
  public:
    InOperatorContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    virtual size_t getContextId() const override;
    antlr4::tree::TerminalNode *In();

   
  };

  virtual InOperatorContext* inOperator();

  class  EqualityOperatorContext : public antlr4::ParserRuleContext {
  public:
    EqualityOperatorContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    virtual size_t getContextId() const override;
    antlr4::tree::TerminalNode *Equals_();
    antlr4::tree::TerminalNode *NotEquals();
    antlr4::tree::TerminalNode *IdentityEquals();

   
  };

  virtual EqualityOperatorContext* equalityOperator();

  class  BitAndOperatorContext : public antlr4::ParserRuleContext {
  public:
    BitAndOperatorContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    virtual size_t getContextId() const override;
    antlr4::tree::TerminalNode *BitAnd();

   
  };

  virtual BitAndOperatorContext* bitAndOperator();

  class  BitOrOperatorContext : public antlr4::ParserRuleContext {
  public:
    BitOrOperatorContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    virtual size_t getContextId() const override;
    antlr4::tree::TerminalNode *BitOr();

   
  };

  virtual BitOrOperatorContext* bitOrOperator();

  class  BitXorOperatorContext : public antlr4::ParserRuleContext {
  public:
    BitXorOperatorContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    virtual size_t getContextId() const override;
    antlr4::tree::TerminalNode *BitXOr();

   
  };

  virtual BitXorOperatorContext* bitXorOperator();

  class  ExpressionContext : public antlr4::ParserRuleContext {
  public:
    CppString type;
    ExpressionContext(antlr4::ParserRuleContext *parent, size_t invokingState);
   
    ExpressionContext() = default;
    void copyFrom(ExpressionContext *context);
    using antlr4::ParserRuleContext::copyFrom;

    virtual size_t getRuleIndex() const override;
    virtual size_t getContextId() const override;

   
  };

  class  GeneratorsExpressionContext : public ExpressionContext {
  public:
    GeneratorsExpressionContext(ExpressionContext *ctx);

    GeneratorBlockContext *generatorBlock();
    virtual size_t getContextId() const override;
  };

  class  ExponentiationExpressionContext : public ExpressionContext {
  public:
    ExponentiationExpressionContext(ExpressionContext *ctx);

    FormalParser::ExpressionContext *left_ = nullptr;
    FormalParser::ExponentiationOperatorContext *operator_ = nullptr;
    FormalParser::ExpressionContext *right_ = nullptr;
    std::vector<ExpressionContext *> expression();
    ExpressionContext* expression(size_t i);
    ExponentiationOperatorContext *exponentiationOperator();
    virtual size_t getContextId() const override;
  };

  class  PatternInvolvedAssignmentExpressionContext : public ExpressionContext {
  public:
    PatternInvolvedAssignmentExpressionContext(ExpressionContext *ctx);

    FormalParser::PatternContext *left_ = nullptr;
    FormalParser::AssignmentOperatorContext *operator_ = nullptr;
    FormalParser::ExpressionContext *right_ = nullptr;
    PatternContext *pattern();
    AssignmentOperatorContext *assignmentOperator();
    ExpressionContext *expression();
    virtual size_t getContextId() const override;
  };

  class  InExpressionContext : public ExpressionContext {
  public:
    InExpressionContext(ExpressionContext *ctx);

    FormalParser::ExpressionContext *left_ = nullptr;
    FormalParser::InOperatorContext *operator_ = nullptr;
    FormalParser::ExpressionContext *right_ = nullptr;
    std::vector<ExpressionContext *> expression();
    ExpressionContext* expression(size_t i);
    InOperatorContext *inOperator();
    virtual size_t getContextId() const override;
  };

  class  UnaryExpressionContext : public ExpressionContext {
  public:
    UnaryExpressionContext(ExpressionContext *ctx);

    FormalParser::UnaryOperatorContext *operator_ = nullptr;
    FormalParser::ExpressionContext *argument_ = nullptr;
    UnaryOperatorContext *unaryOperator();
    ExpressionContext *expression();
    virtual size_t getContextId() const override;
  };

  class  AwaitExpressionContext : public ExpressionContext {
  public:
    AwaitExpressionContext(ExpressionContext *ctx);

    FormalParser::ExpressionContext *argument_ = nullptr;
    antlr4::tree::TerminalNode *Await();
    ExpressionContext *expression();
    virtual size_t getContextId() const override;
  };

  class  ThisExpressionContext : public ExpressionContext {
  public:
    ThisExpressionContext(ExpressionContext *ctx);

    antlr4::tree::TerminalNode *This();
    virtual size_t getContextId() const override;
  };

  class  LogicalExpressionContext : public ExpressionContext {
  public:
    LogicalExpressionContext(ExpressionContext *ctx);

    FormalParser::ExpressionContext *left_ = nullptr;
    FormalParser::ExpressionContext *right_ = nullptr;
    antlr4::tree::TerminalNode *And();
    std::vector<ExpressionContext *> expression();
    ExpressionContext* expression(size_t i);
    antlr4::tree::TerminalNode *Or();
    antlr4::tree::TerminalNode *DoubleQuestionMark();
    virtual size_t getContextId() const override;
  };

  class  FunctionExpressionContext : public ExpressionContext {
  public:
    FunctionExpressionContext(ExpressionContext *ctx);

    FormalParser::BaseFunctionContext *baseFunction_ = nullptr;
    FormalParser::BraceBlockContext *body_ = nullptr;
    BaseFunctionContext *baseFunction();
    BraceBlockContext *braceBlock();
    virtual size_t getContextId() const override;
  };

  class  AssignmentExpressionContext : public ExpressionContext {
  public:
    AssignmentExpressionContext(ExpressionContext *ctx);

    FormalParser::ExpressionContext *left_ = nullptr;
    FormalParser::AssignmentOperatorContext *operator_ = nullptr;
    FormalParser::ExpressionContext *right_ = nullptr;
    std::vector<ExpressionContext *> expression();
    ExpressionContext* expression(size_t i);
    AssignmentOperatorContext *assignmentOperator();
    virtual size_t getContextId() const override;
  };

  class  TaggedTemplateExpressionContext : public ExpressionContext {
  public:
    TaggedTemplateExpressionContext(ExpressionContext *ctx);

    FormalParser::ExpressionContext *tag_ = nullptr;
    FormalParser::TemplateLiteralContext *quasi_ = nullptr;
    ExpressionContext *expression();
    TemplateLiteralContext *templateLiteral();
    virtual size_t getContextId() const override;
  };

  class  InstanceofExpressionContext : public ExpressionContext {
  public:
    InstanceofExpressionContext(ExpressionContext *ctx);

    FormalParser::ExpressionContext *left_ = nullptr;
    FormalParser::InstanceofOperatorContext *operator_ = nullptr;
    FormalParser::ExpressionContext *right_ = nullptr;
    std::vector<ExpressionContext *> expression();
    ExpressionContext* expression(size_t i);
    InstanceofOperatorContext *instanceofOperator();
    virtual size_t getContextId() const override;
  };

  class  GeneratorsFunctionExpressionContext : public ExpressionContext {
  public:
    GeneratorsFunctionExpressionContext(ExpressionContext *ctx);

    GeneratorFunctionDeclarationContext *generatorFunctionDeclaration();
    virtual size_t getContextId() const override;
  };

  class  ImportExpressionContext : public ExpressionContext {
  public:
    ImportExpressionContext(ExpressionContext *ctx);

    FormalParser::ExpressionContext *source_ = nullptr;
    antlr4::tree::TerminalNode *Import();
    antlr4::tree::TerminalNode *OpenParen();
    antlr4::tree::TerminalNode *CloseParen();
    ExpressionContext *expression();
    virtual size_t getContextId() const override;
  };

  class  ArrowFunctionExpressionContext : public ExpressionContext {
  public:
    ArrowFunctionExpressionContext(ExpressionContext *ctx);

    FormalParser::ArrowFunctionParametersContext *params_ = nullptr;
    FormalParser::FunctionReturnTypeContext *typeAnnotation_ = nullptr;
    FormalParser::ArrowFunctionBodyContext *body_ = nullptr;
    antlr4::tree::TerminalNode *ARROW();
    ArrowFunctionParametersContext *arrowFunctionParameters();
    ArrowFunctionBodyContext *arrowFunctionBody();
    antlr4::tree::TerminalNode *Async();
    FunctionReturnTypeContext *functionReturnType();
    virtual size_t getContextId() const override;
  };

  class  IteratorsExpressionContext : public ExpressionContext {
  public:
    IteratorsExpressionContext(ExpressionContext *ctx);

    IteratorBlockContext *iteratorBlock();
    virtual size_t getContextId() const override;
  };

  class  MetaPropertyContext : public ExpressionContext {
  public:
    MetaPropertyContext(ExpressionContext *ctx);

    FormalParser::MetaPropertyIdentifierContext *meta_ = nullptr;
    FormalParser::IdentifierContext *property_ = nullptr;
    antlr4::tree::TerminalNode *Dot();
    MetaPropertyIdentifierContext *metaPropertyIdentifier();
    IdentifierContext *identifier();
    virtual size_t getContextId() const override;
  };

  class  EqualityExpressionContext : public ExpressionContext {
  public:
    EqualityExpressionContext(ExpressionContext *ctx);

    FormalParser::ExpressionContext *left_ = nullptr;
    FormalParser::EqualityOperatorContext *operator_ = nullptr;
    FormalParser::ExpressionContext *right_ = nullptr;
    std::vector<ExpressionContext *> expression();
    ExpressionContext* expression(size_t i);
    EqualityOperatorContext *equalityOperator();
    virtual size_t getContextId() const override;
  };

  class  UpdateExpressionContext : public ExpressionContext {
  public:
    UpdateExpressionContext(ExpressionContext *ctx);

    FormalParser::ExpressionContext *argument_ = nullptr;
    FormalParser::UpdateOperatorContext *operator_ = nullptr;
    UpdateOperatorContext *updateOperator();
    ExpressionContext *expression();
    virtual size_t getContextId() const override;
  };

  class  SuperExpressionContext : public ExpressionContext {
  public:
    SuperExpressionContext(ExpressionContext *ctx);

    antlr4::tree::TerminalNode *Super();
    virtual size_t getContextId() const override;
  };

  class  MultiplicativeExpressionContext : public ExpressionContext {
  public:
    MultiplicativeExpressionContext(ExpressionContext *ctx);

    FormalParser::ExpressionContext *left_ = nullptr;
    FormalParser::MultiplicativeOperatorContext *operator_ = nullptr;
    FormalParser::ExpressionContext *right_ = nullptr;
    std::vector<ExpressionContext *> expression();
    ExpressionContext* expression(size_t i);
    MultiplicativeOperatorContext *multiplicativeOperator();
    virtual size_t getContextId() const override;
  };

  class  CallExpressionContext : public ExpressionContext {
  public:
    CallExpressionContext(ExpressionContext *ctx);

    FormalParser::ExpressionContext *callee_ = nullptr;
    FormalParser::ArgumentArrayListContext *arguments_ = nullptr;
    antlr4::tree::TerminalNode *OpenParen();
    antlr4::tree::TerminalNode *CloseParen();
    ExpressionContext *expression();
    antlr4::tree::TerminalNode *OptionalChainingOperator();
    ArgumentArrayListContext *argumentArrayList();
    virtual size_t getContextId() const override;
  };

  class  BitShiftExpressionContext : public ExpressionContext {
  public:
    BitShiftExpressionContext(ExpressionContext *ctx);

    FormalParser::ExpressionContext *left_ = nullptr;
    FormalParser::BitShiftOperatorContext *operator_ = nullptr;
    FormalParser::ExpressionContext *right_ = nullptr;
    std::vector<ExpressionContext *> expression();
    ExpressionContext* expression(size_t i);
    BitShiftOperatorContext *bitShiftOperator();
    virtual size_t getContextId() const override;
  };

  class  ParenthesizedExpressionContext : public ExpressionContext {
  public:
    ParenthesizedExpressionContext(ExpressionContext *ctx);

    FormalParser::ExpressionSequenceContext *expression_ = nullptr;
    antlr4::tree::TerminalNode *OpenParen();
    antlr4::tree::TerminalNode *CloseParen();
    ExpressionSequenceContext *expressionSequence();
    virtual size_t getContextId() const override;
  };

  class  AdditiveExpressionContext : public ExpressionContext {
  public:
    AdditiveExpressionContext(ExpressionContext *ctx);

    FormalParser::ExpressionContext *left_ = nullptr;
    FormalParser::AdditiveOperatorContext *operator_ = nullptr;
    FormalParser::ExpressionContext *right_ = nullptr;
    std::vector<ExpressionContext *> expression();
    ExpressionContext* expression(size_t i);
    AdditiveOperatorContext *additiveOperator();
    virtual size_t getContextId() const override;
  };

  class  RelationalExpressionContext : public ExpressionContext {
  public:
    RelationalExpressionContext(ExpressionContext *ctx);

    FormalParser::ExpressionContext *left_ = nullptr;
    FormalParser::RelationalOperatorContext *operator_ = nullptr;
    FormalParser::ExpressionContext *right_ = nullptr;
    std::vector<ExpressionContext *> expression();
    ExpressionContext* expression(size_t i);
    RelationalOperatorContext *relationalOperator();
    virtual size_t getContextId() const override;
  };

  class  YieldExpressionContext : public ExpressionContext {
  public:
    YieldExpressionContext(ExpressionContext *ctx);

    FormalParser::ExpressionContext *argument_ = nullptr;
    antlr4::tree::TerminalNode *Yield();
    ExpressionContext *expression();
    antlr4::tree::TerminalNode *Multiply();
    virtual size_t getContextId() const override;
  };

  class  QuestionMarkFollowedByDecimalDirectlyConditionExpressionContext : public ExpressionContext {
  public:
    QuestionMarkFollowedByDecimalDirectlyConditionExpressionContext(ExpressionContext *ctx);

    FormalParser::ExpressionContext *test_ = nullptr;
    FormalParser::ExpressionContext *alternate_ = nullptr;
    antlr4::tree::TerminalNode *QuestionMarkFollowedByDecimalDirectly();
    antlr4::tree::TerminalNode *Colon();
    std::vector<ExpressionContext *> expression();
    ExpressionContext* expression(size_t i);
    virtual size_t getContextId() const override;
  };

  class  NewExpressionContext : public ExpressionContext {
  public:
    NewExpressionContext(ExpressionContext *ctx);

    FormalParser::ExpressionContext *callee = nullptr;
    FormalParser::ArgumentArrayListContext *arguments_ = nullptr;
    antlr4::tree::TerminalNode *New();
    antlr4::tree::TerminalNode *OpenParen();
    antlr4::tree::TerminalNode *CloseParen();
    ExpressionContext *expression();
    ArgumentArrayListContext *argumentArrayList();
    virtual size_t getContextId() const override;
  };

  class  LiteralExpressionContext : public ExpressionContext {
  public:
    LiteralExpressionContext(ExpressionContext *ctx);

    LiteralContext *literal();
    virtual size_t getContextId() const override;
  };

  class  ConditionalExpressionContext : public ExpressionContext {
  public:
    ConditionalExpressionContext(ExpressionContext *ctx);

    FormalParser::ExpressionContext *test_ = nullptr;
    FormalParser::ExpressionContext *consequent_ = nullptr;
    FormalParser::ExpressionContext *alternate_ = nullptr;
    antlr4::tree::TerminalNode *QuestionMark();
    antlr4::tree::TerminalNode *Colon();
    std::vector<ExpressionContext *> expression();
    ExpressionContext* expression(size_t i);
    virtual size_t getContextId() const override;
  };

  class  BitXorExpressionContext : public ExpressionContext {
  public:
    BitXorExpressionContext(ExpressionContext *ctx);

    FormalParser::ExpressionContext *left_ = nullptr;
    FormalParser::BitXorOperatorContext *operator_ = nullptr;
    FormalParser::ExpressionContext *right_ = nullptr;
    std::vector<ExpressionContext *> expression();
    ExpressionContext* expression(size_t i);
    BitXorOperatorContext *bitXorOperator();
    virtual size_t getContextId() const override;
  };

  class  ClassExpressionContext : public ExpressionContext {
  public:
    ClassExpressionContext(ExpressionContext *ctx);

    BaseClassContext *baseClass();
    virtual size_t getContextId() const override;
  };

  class  TSAsExpressionContext : public ExpressionContext {
  public:
    TSAsExpressionContext(ExpressionContext *ctx);

    FormalParser::ExpressionContext *expression_ = nullptr;
    FormalParser::Type_Context *typeAnnotation_ = nullptr;
    FormalParser::ExpressionContext *asExpression_ = nullptr;
    antlr4::tree::TerminalNode *As();
    std::vector<ExpressionContext *> expression();
    ExpressionContext* expression(size_t i);
    Type_Context *type_();
    antlr4::tree::TerminalNode *OpenBracket();
    antlr4::tree::TerminalNode *CloseBracket();
    virtual size_t getContextId() const override;
  };

  class  IdentifierExpressionContext : public ExpressionContext {
  public:
    IdentifierExpressionContext(ExpressionContext *ctx);

    IdentifierContext *identifier();
    virtual size_t getContextId() const override;
  };

  class  MemberExpressionContext : public ExpressionContext {
  public:
    MemberExpressionContext(ExpressionContext *ctx);

    FormalParser::ExpressionContext *object_ = nullptr;
    FormalParser::MemberExpressionPropertyContext *property_ = nullptr;
    ExpressionContext *expression();
    MemberExpressionPropertyContext *memberExpressionProperty();
    virtual size_t getContextId() const override;
  };

  class  BitAndExpressionContext : public ExpressionContext {
  public:
    BitAndExpressionContext(ExpressionContext *ctx);

    FormalParser::ExpressionContext *left_ = nullptr;
    FormalParser::BitAndOperatorContext *operator_ = nullptr;
    FormalParser::ExpressionContext *right_ = nullptr;
    std::vector<ExpressionContext *> expression();
    ExpressionContext* expression(size_t i);
    BitAndOperatorContext *bitAndOperator();
    virtual size_t getContextId() const override;
  };

  class  BitOrExpressionContext : public ExpressionContext {
  public:
    BitOrExpressionContext(ExpressionContext *ctx);

    FormalParser::ExpressionContext *left_ = nullptr;
    FormalParser::BitOrOperatorContext *operator_ = nullptr;
    FormalParser::ExpressionContext *right_ = nullptr;
    std::vector<ExpressionContext *> expression();
    ExpressionContext* expression(size_t i);
    BitOrOperatorContext *bitOrOperator();
    virtual size_t getContextId() const override;
  };

  class  ArrayExpressionContext : public ExpressionContext {
  public:
    ArrayExpressionContext(ExpressionContext *ctx);

    FormalParser::ArrayElementArrayListContext *elements_ = nullptr;
    antlr4::tree::TerminalNode *OpenBracket();
    antlr4::tree::TerminalNode *CloseBracket();
    ArrayElementArrayListContext *arrayElementArrayList();
    virtual size_t getContextId() const override;
  };

  class  ObjectExpressionContext : public ExpressionContext {
  public:
    ObjectExpressionContext(ExpressionContext *ctx);

    FormalParser::ObjectElementArrayListContext *properties_ = nullptr;
    antlr4::tree::TerminalNode *OpenBrace();
    antlr4::tree::TerminalNode *CloseBrace();
    ObjectElementArrayListContext *objectElementArrayList();
    virtual size_t getContextId() const override;
  };

  class  TemplateLiteralExpressionContext : public ExpressionContext {
  public:
    TemplateLiteralExpressionContext(ExpressionContext *ctx);

    TemplateLiteralContext *templateLiteral();
    virtual size_t getContextId() const override;
  };

  virtual ExpressionContext* expression();
  virtual ExpressionContext* expression(int precedence);
  class  IdentifierContext : public antlr4::ParserRuleContext {
  public:
    CppString type;
    CppString name;
    FormalParser::TypeAnnotationContext *typeAnnotation_ = nullptr;;
    IdentifierContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    virtual size_t getContextId() const override;
    antlr4::tree::TerminalNode *Identifier();
    TypeAnnotationContext *typeAnnotation();
    antlr4::tree::TerminalNode *SingQuote();
    antlr4::tree::TerminalNode *DoubleQuote();
    NumericLiteralContext *numericLiteral();
    KeywordContext *keyword();
    JsPrimitiveTypeContext *jsPrimitiveType();
    ExtendedPrimitiveTypeContext *extendedPrimitiveType();
    antlr4::tree::TerminalNode *BooleanLiteral();

   
  };

  virtual IdentifierContext* identifier();

  class  MetaPropertyIdentifierContext : public antlr4::ParserRuleContext {
  public:
    CppString type;
    CppString name;
    MetaPropertyIdentifierContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    virtual size_t getContextId() const override;
    antlr4::tree::TerminalNode *New();
    antlr4::tree::TerminalNode *Import();

   
  };

  virtual MetaPropertyIdentifierContext* metaPropertyIdentifier();

  class  PrivateIdentifierContext : public antlr4::ParserRuleContext {
  public:
    CppString type;
    CppString name;
    antlr4::Token *identifierToken = nullptr;;
    PrivateIdentifierContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    virtual size_t getContextId() const override;
    antlr4::tree::TerminalNode *Hashtag();
    antlr4::tree::TerminalNode *Identifier();

   
  };

  virtual PrivateIdentifierContext* privateIdentifier();

  class  MemberExpressionPropertyContext : public antlr4::ParserRuleContext {
  public:
    CppString type;
    boolean computed;
    boolean optional;
    MemberExpressionPropertyContext(antlr4::ParserRuleContext *parent, size_t invokingState);
   
    MemberExpressionPropertyContext() = default;
    void copyFrom(MemberExpressionPropertyContext *context);
    using antlr4::ParserRuleContext::copyFrom;

    virtual size_t getRuleIndex() const override;
    virtual size_t getContextId() const override;

   
  };

  class  DotMemberExpressionContext : public MemberExpressionPropertyContext {
  public:
    DotMemberExpressionContext(MemberExpressionPropertyContext *ctx);

    antlr4::tree::TerminalNode *OptionalChainingOperator();
    IdentifierContext *identifier();
    antlr4::tree::TerminalNode *Dot();
    virtual size_t getContextId() const override;
  };

  class  PrivateMemberExpressionContext : public MemberExpressionPropertyContext {
  public:
    PrivateMemberExpressionContext(MemberExpressionPropertyContext *ctx);

    antlr4::tree::TerminalNode *Dot();
    PrivateIdentifierContext *privateIdentifier();
    virtual size_t getContextId() const override;
  };

  class  BracketMemberExpressionContext : public MemberExpressionPropertyContext {
  public:
    BracketMemberExpressionContext(MemberExpressionPropertyContext *ctx);

    FormalParser::ExpressionSequenceContext *expression_ = nullptr;
    antlr4::tree::TerminalNode *OpenBracket();
    antlr4::tree::TerminalNode *CloseBracket();
    ExpressionSequenceContext *expressionSequence();
    antlr4::tree::TerminalNode *OptionalChainingOperator();
    virtual size_t getContextId() const override;
  };

  virtual MemberExpressionPropertyContext* memberExpressionProperty();

  class  ArrowFunctionParametersContext : public antlr4::ParserRuleContext {
  public:
    ArrowFunctionParametersContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    virtual size_t getContextId() const override;
    antlr4::tree::TerminalNode *OpenParen();
    antlr4::tree::TerminalNode *CloseParen();
    ParameterListContext *parameterList();
    IdentifierContext *identifier();

   
  };

  virtual ArrowFunctionParametersContext* arrowFunctionParameters();

  class  ArrowFunctionBodyContext : public antlr4::ParserRuleContext {
  public:
    ArrowFunctionBodyContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    virtual size_t getContextId() const override;
    BraceBlockContext *braceBlock();
    ExpressionContext *expression();

   
  };

  virtual ArrowFunctionBodyContext* arrowFunctionBody();

  class  AssignmentOperatorContext : public antlr4::ParserRuleContext {
  public:
    AssignmentOperatorContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    virtual size_t getContextId() const override;
    antlr4::tree::TerminalNode *Assign();
    antlr4::tree::TerminalNode *MultiplyAssign();
    antlr4::tree::TerminalNode *DivideAssign();
    antlr4::tree::TerminalNode *ModulusAssign();
    antlr4::tree::TerminalNode *ExponentiationAssign();
    antlr4::tree::TerminalNode *PlusAssign();
    antlr4::tree::TerminalNode *MinusAssign();
    antlr4::tree::TerminalNode *LeftShiftArithmeticAssign();
    antlr4::tree::TerminalNode *RightShiftArithmeticAssign();
    antlr4::tree::TerminalNode *RightShiftLogicalAssign();
    antlr4::tree::TerminalNode *BitAndAssign();
    antlr4::tree::TerminalNode *BitXorAssign();
    antlr4::tree::TerminalNode *BitOrAssign();

   
  };

  virtual AssignmentOperatorContext* assignmentOperator();

  class  NumericLiteralContext : public antlr4::ParserRuleContext {
  public:
    NumericLiteralContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    virtual size_t getContextId() const override;
    antlr4::tree::TerminalNode *DecimalLiteral();
    antlr4::tree::TerminalNode *HexIntegerLiteral();
    antlr4::tree::TerminalNode *OctalIntegerLiteral();
    antlr4::tree::TerminalNode *OctalIntegerLiteral2();
    antlr4::tree::TerminalNode *BinaryIntegerLiteral();

   
  };

  virtual NumericLiteralContext* numericLiteral();

  class  LiteralContext : public antlr4::ParserRuleContext {
  public:
    CppString type;
    LiteralContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    virtual size_t getContextId() const override;
    antlr4::tree::TerminalNode *NullLiteral();
    antlr4::tree::TerminalNode *BooleanLiteral();
    antlr4::tree::TerminalNode *StringLiteral();
    antlr4::tree::TerminalNode *RegularExpressionLiteral();
    NumericLiteralContext *numericLiteral();
    antlr4::tree::TerminalNode *BigInt();

   
  };

  virtual LiteralContext* literal();

  class  TemplateLiteralContext : public antlr4::ParserRuleContext {
  public:
    CppString type;
    FormalParser::TemplateStringAtomContext *templateStringAtom_ = nullptr;;
    TemplateLiteralContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    virtual size_t getContextId() const override;
    std::vector<antlr4::tree::TerminalNode *> BackTick();
    antlr4::tree::TerminalNode* BackTick(size_t i);
    std::vector<TemplateStringAtomContext *> templateStringAtom();
    TemplateStringAtomContext* templateStringAtom(size_t i);

   
  };

  virtual TemplateLiteralContext* templateLiteral();

  class  TemplateStringAtomContext : public antlr4::ParserRuleContext {
  public:
    TemplateStringAtomContext(antlr4::ParserRuleContext *parent, size_t invokingState);
   
    TemplateStringAtomContext() = default;
    void copyFrom(TemplateStringAtomContext *context);
    using antlr4::ParserRuleContext::copyFrom;

    virtual size_t getRuleIndex() const override;
    virtual size_t getContextId() const override;

   
  };

  class  AtomTemplateStringContext : public TemplateStringAtomContext {
  public:
    AtomTemplateStringContext(TemplateStringAtomContext *ctx);

    antlr4::tree::TerminalNode *TemplateStringAtom();
    virtual size_t getContextId() const override;
  };

  class  BraceTemplateStringContext : public TemplateStringAtomContext {
  public:
    BraceTemplateStringContext(TemplateStringAtomContext *ctx);

    FormalParser::ExpressionContext *expression_ = nullptr;
    antlr4::tree::TerminalNode *TemplateStringStartExpression();
    antlr4::tree::TerminalNode *TemplateCloseBrace();
    ExpressionContext *expression();
    virtual size_t getContextId() const override;
  };

  virtual TemplateStringAtomContext* templateStringAtom();

  class  KeywordContext : public antlr4::ParserRuleContext {
  public:
    KeywordContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    virtual size_t getContextId() const override;
    antlr4::tree::TerminalNode *Break();
    antlr4::tree::TerminalNode *Do();
    antlr4::tree::TerminalNode *Instanceof();
    antlr4::tree::TerminalNode *Typeof();
    antlr4::tree::TerminalNode *Case();
    antlr4::tree::TerminalNode *Else();
    antlr4::tree::TerminalNode *New();
    antlr4::tree::TerminalNode *Var();
    antlr4::tree::TerminalNode *Catch();
    antlr4::tree::TerminalNode *Finally();
    antlr4::tree::TerminalNode *Return();
    antlr4::tree::TerminalNode *Void();
    antlr4::tree::TerminalNode *Continue();
    antlr4::tree::TerminalNode *For();
    antlr4::tree::TerminalNode *Switch();
    antlr4::tree::TerminalNode *While();
    antlr4::tree::TerminalNode *Debugger();
    antlr4::tree::TerminalNode *Function_();
    antlr4::tree::TerminalNode *This();
    antlr4::tree::TerminalNode *With();
    antlr4::tree::TerminalNode *Default();
    antlr4::tree::TerminalNode *If();
    antlr4::tree::TerminalNode *Throw();
    antlr4::tree::TerminalNode *Delete();
    antlr4::tree::TerminalNode *In();
    antlr4::tree::TerminalNode *Of();
    antlr4::tree::TerminalNode *Try();
    antlr4::tree::TerminalNode *ReadOnly();
    antlr4::tree::TerminalNode *Async();
    antlr4::tree::TerminalNode *From();
    antlr4::tree::TerminalNode *Class();
    antlr4::tree::TerminalNode *Enum();
    antlr4::tree::TerminalNode *Extends();
    antlr4::tree::TerminalNode *Super();
    antlr4::tree::TerminalNode *Const();
    antlr4::tree::TerminalNode *Export();
    antlr4::tree::TerminalNode *Import();
    antlr4::tree::TerminalNode *Implements();
    antlr4::tree::TerminalNode *Let();
    antlr4::tree::TerminalNode *Private();
    antlr4::tree::TerminalNode *Public();
    antlr4::tree::TerminalNode *Interface();
    antlr4::tree::TerminalNode *Package();
    antlr4::tree::TerminalNode *Protected();
    antlr4::tree::TerminalNode *Static();
    antlr4::tree::TerminalNode *Yield();
    antlr4::tree::TerminalNode *Get();
    antlr4::tree::TerminalNode *Set();
    antlr4::tree::TerminalNode *TypeAlias();
    antlr4::tree::TerminalNode *String();

   
  };

  virtual KeywordContext* keyword();

  class  GetterContext : public antlr4::ParserRuleContext {
  public:
    FormalParser::PropertyNameContext *propertyName_ = nullptr;;
    GetterContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    virtual size_t getContextId() const override;
    antlr4::tree::TerminalNode *Get();
    PropertyNameContext *propertyName();

   
  };

  virtual GetterContext* getter();

  class  SetterContext : public antlr4::ParserRuleContext {
  public:
    FormalParser::PropertyNameContext *propertyName_ = nullptr;;
    SetterContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    virtual size_t getContextId() const override;
    antlr4::tree::TerminalNode *Set();
    PropertyNameContext *propertyName();

   
  };

  virtual SetterContext* setter();

  class  EosContext : public antlr4::ParserRuleContext {
  public:
    EosContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    virtual size_t getContextId() const override;
    antlr4::tree::TerminalNode *SemiColon();
    antlr4::tree::TerminalNode *EOF();

   
  };

  virtual EosContext* eos();

  class  AssignableContext : public antlr4::ParserRuleContext {
  public:
    AssignableContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    virtual size_t getContextId() const override;
    PatternContext *pattern();
    ExpressionContext *expression();

   
  };

  virtual AssignableContext* assignable();

  class  TypeAnnotationContext : public antlr4::ParserRuleContext {
  public:
    CppString type;
    FormalParser::Type_Context *typeAnnotation_ = nullptr;;
    TypeAnnotationContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    virtual size_t getContextId() const override;
    antlr4::tree::TerminalNode *Colon();
    Type_Context *type_();

   
  };

  virtual TypeAnnotationContext* typeAnnotation();

  class  QualifiedNameContext : public antlr4::ParserRuleContext {
  public:
    CppString type;
    QualifiedNameContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    virtual size_t getContextId() const override;
    std::vector<IdentifierContext *> identifier();
    IdentifierContext* identifier(size_t i);
    std::vector<antlr4::tree::TerminalNode *> Dot();
    antlr4::tree::TerminalNode* Dot(size_t i);
    antlr4::tree::TerminalNode *This();

   
  };

  virtual QualifiedNameContext* qualifiedName();

  class  TypeNameContext : public antlr4::ParserRuleContext {
  public:
    TypeNameContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    virtual size_t getContextId() const override;
    IdentifierContext *identifier();
    QualifiedNameContext *qualifiedName();

   
  };

  virtual TypeNameContext* typeName();

  class  JsPrimitiveTypeContext : public antlr4::ParserRuleContext {
  public:
    JsPrimitiveTypeContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    virtual size_t getContextId() const override;
    antlr4::tree::TerminalNode *Boolean();
    antlr4::tree::TerminalNode *Number();
    antlr4::tree::TerminalNode *String();
    antlr4::tree::TerminalNode *NullLiteral();
    antlr4::tree::TerminalNode *Symbol();
    antlr4::tree::TerminalNode *Undefined();
    antlr4::tree::TerminalNode *BigIntAnnotation();

   
  };

  virtual JsPrimitiveTypeContext* jsPrimitiveType();

  class  ExtendedPrimitiveTypeContext : public antlr4::ParserRuleContext {
  public:
    ExtendedPrimitiveTypeContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    virtual size_t getContextId() const override;
    antlr4::tree::TerminalNode *Int8();
    antlr4::tree::TerminalNode *Int16();
    antlr4::tree::TerminalNode *Int32();
    antlr4::tree::TerminalNode *Int64();
    antlr4::tree::TerminalNode *Uint8();
    antlr4::tree::TerminalNode *Uint16();
    antlr4::tree::TerminalNode *Uint32();
    antlr4::tree::TerminalNode *Uint64();
    antlr4::tree::TerminalNode *Float();
    antlr4::tree::TerminalNode *Double();
    antlr4::tree::TerminalNode *Decimal();

   
  };

  virtual ExtendedPrimitiveTypeContext* extendedPrimitiveType();

  class  TypeListContext : public antlr4::ParserRuleContext {
  public:
    boolean isArrayList;
    TypeListContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    virtual size_t getContextId() const override;
    std::vector<Type_Context *> type_();
    Type_Context* type_(size_t i);
    std::vector<antlr4::tree::TerminalNode *> Comma();
    antlr4::tree::TerminalNode* Comma(size_t i);

   
  };

  virtual TypeListContext* typeList();

  class  AnonymousObjectPropertyListSeparatorContext : public antlr4::ParserRuleContext {
  public:
    AnonymousObjectPropertyListSeparatorContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    virtual size_t getContextId() const override;
    antlr4::tree::TerminalNode *Comma();
    antlr4::tree::TerminalNode *SemiColon();

   
  };

  virtual AnonymousObjectPropertyListSeparatorContext* anonymousObjectPropertyListSeparator();

  class  AnonymousObjectPropertyListContext : public antlr4::ParserRuleContext {
  public:
    boolean isArrayList;
    AnonymousObjectPropertyListContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    virtual size_t getContextId() const override;
    std::vector<ObjectPropertyPairContext *> objectPropertyPair();
    ObjectPropertyPairContext* objectPropertyPair(size_t i);
    std::vector<AnonymousObjectPropertyListSeparatorContext *> anonymousObjectPropertyListSeparator();
    AnonymousObjectPropertyListSeparatorContext* anonymousObjectPropertyListSeparator(size_t i);

   
  };

  virtual AnonymousObjectPropertyListContext* anonymousObjectPropertyList();

  class  ObjectPropertyPairContext : public antlr4::ParserRuleContext {
  public:
    FormalParser::IdentifierContext *key = nullptr;;
    FormalParser::Type_Context *value = nullptr;;
    ObjectPropertyPairContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    virtual size_t getContextId() const override;
    antlr4::tree::TerminalNode *Colon();
    IdentifierContext *identifier();
    Type_Context *type_();

   
  };

  virtual ObjectPropertyPairContext* objectPropertyPair();

  class  GenericKindContext : public antlr4::ParserRuleContext {
  public:
    GenericKindContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    virtual size_t getContextId() const override;
    antlr4::tree::TerminalNode *Array();
    antlr4::tree::TerminalNode *Object();

   
  };

  virtual GenericKindContext* genericKind();

  class  CommaGenericContext : public antlr4::ParserRuleContext {
  public:
    CppString type;
    FormalParser::GenericKindContext *t0 = nullptr;;
    FormalParser::Type_Context *internalType = nullptr;;
    CommaGenericContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    virtual size_t getContextId() const override;
    antlr4::tree::TerminalNode *Comma();
    GenericKindContext *genericKind();
    Type_Context *type_();

   
  };

  virtual CommaGenericContext* commaGeneric();

  class  AngleGenericContext : public antlr4::ParserRuleContext {
  public:
    CppString type;
    FormalParser::GenericKindContext *t0 = nullptr;;
    FormalParser::Type_Context *internalType = nullptr;;
    FormalParser::GenericKindContext *t1 = nullptr;;
    FormalParser::GenericKindContext *t2 = nullptr;;
    AngleGenericContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    virtual size_t getContextId() const override;
    std::vector<antlr4::tree::TerminalNode *> LessThan();
    antlr4::tree::TerminalNode* LessThan(size_t i);
    std::vector<antlr4::tree::TerminalNode *> MoreThan();
    antlr4::tree::TerminalNode* MoreThan(size_t i);
    std::vector<GenericKindContext *> genericKind();
    GenericKindContext* genericKind(size_t i);
    Type_Context *type_();
    antlr4::tree::TerminalNode *RightShiftArithmetic();
    antlr4::tree::TerminalNode *RightShiftLogical();

   
  };

  virtual AngleGenericContext* angleGeneric();

  class  ObjectOrArrayGenericTypeContext : public antlr4::ParserRuleContext {
  public:
    ObjectOrArrayGenericTypeContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    virtual size_t getContextId() const override;
    CommaGenericContext *commaGeneric();
    AngleGenericContext *angleGeneric();

   
  };

  virtual ObjectOrArrayGenericTypeContext* objectOrArrayGenericType();

  class  Type_Context : public antlr4::ParserRuleContext {
  public:
    CppString type;
    Type_Context(antlr4::ParserRuleContext *parent, size_t invokingState);
   
    Type_Context() = default;
    void copyFrom(Type_Context *context);
    using antlr4::ParserRuleContext::copyFrom;

    virtual size_t getRuleIndex() const override;
    virtual size_t getContextId() const override;

   
  };

  class  UnionTypeContext : public Type_Context {
  public:
    UnionTypeContext(Type_Context *ctx);

    std::vector<Type_Context *> type_();
    Type_Context* type_(size_t i);
    std::vector<antlr4::tree::TerminalNode *> BitOr();
    antlr4::tree::TerminalNode* BitOr(size_t i);
    virtual size_t getContextId() const override;
  };

  class  GenericTypeContext : public Type_Context {
  public:
    GenericTypeContext(Type_Context *ctx);

    ObjectOrArrayGenericTypeContext *objectOrArrayGenericType();
    virtual size_t getContextId() const override;
  };

  class  ParenthesizedPrimTypeContext : public Type_Context {
  public:
    ParenthesizedPrimTypeContext(Type_Context *ctx);

    FormalParser::Type_Context *internalType = nullptr;
    antlr4::tree::TerminalNode *OpenParen();
    antlr4::tree::TerminalNode *CloseParen();
    Type_Context *type_();
    virtual size_t getContextId() const override;
  };

  class  TupleTypeContext : public Type_Context {
  public:
    TupleTypeContext(Type_Context *ctx);

    FormalParser::TypeListContext *elements = nullptr;
    antlr4::tree::TerminalNode *OpenBracket();
    antlr4::tree::TerminalNode *CloseBracket();
    TypeListContext *typeList();
    virtual size_t getContextId() const override;
  };

  class  PrimitiveTypeContext : public Type_Context {
  public:
    PrimitiveTypeContext(Type_Context *ctx);

    JsPrimitiveTypeContext *jsPrimitiveType();
    ExtendedPrimitiveTypeContext *extendedPrimitiveType();
    antlr4::tree::TerminalNode *Any();
    virtual size_t getContextId() const override;
  };

  class  TypeReferenceContext : public Type_Context {
  public:
    TypeReferenceContext(Type_Context *ctx);

    FormalParser::TypeNameContext *typeName_ = nullptr;
    TypeNameContext *typeName();
    virtual size_t getContextId() const override;
  };

  class  StructContext : public Type_Context {
  public:
    StructContext(Type_Context *ctx);

    FormalParser::AnonymousObjectPropertyListContext *properties = nullptr;
    antlr4::tree::TerminalNode *OpenBrace();
    antlr4::tree::TerminalNode *CloseBrace();
    AnonymousObjectPropertyListContext *anonymousObjectPropertyList();
    virtual size_t getContextId() const override;
  };

  virtual Type_Context* type_();
  virtual Type_Context* type_(int precedence);
  class  TypeAnnotContext : public antlr4::ParserRuleContext {
  public:
    TypeAnnotContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    virtual size_t getContextId() const override;
    Type_Context *type_();
    EosContext *eos();

   
  };

  virtual TypeAnnotContext* typeAnnot();

  class  TypePredicateContext : public antlr4::ParserRuleContext {
  public:
    FormalParser::IdentifierContext *parameterName_ = nullptr;;
    FormalParser::Type_Context *typeAnnotation_ = nullptr;;
    TypePredicateContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    virtual size_t getContextId() const override;
    antlr4::tree::TerminalNode *Is();
    IdentifierContext *identifier();
    Type_Context *type_();

   
  };

  virtual TypePredicateContext* typePredicate();

  class  FunctionReturnTypeContext : public antlr4::ParserRuleContext {
  public:
    FunctionReturnTypeContext(antlr4::ParserRuleContext *parent, size_t invokingState);
    virtual size_t getRuleIndex() const override;
    virtual size_t getContextId() const override;
    Type_Context *type_();
    antlr4::tree::TerminalNode *Void();
    TypePredicateContext *typePredicate();

   
  };

  virtual FunctionReturnTypeContext* functionReturnType();


  virtual bool sempred(antlr4::RuleContext *_localctx, size_t ruleIndex, size_t predicateIndex) override;
  bool patternSempred(PatternContext *_localctx, size_t predicateIndex);
  bool statementSempred(StatementContext *_localctx, size_t predicateIndex);
  bool expressionSempred(ExpressionContext *_localctx, size_t predicateIndex);
  bool identifierSempred(IdentifierContext *_localctx, size_t predicateIndex);
  bool eosSempred(EosContext *_localctx, size_t predicateIndex);
  bool jsPrimitiveTypeSempred(JsPrimitiveTypeContext *_localctx, size_t predicateIndex);
  bool type_Sempred(Type_Context *_localctx, size_t predicateIndex);

private:
  static std::vector<antlr4::dfa::DFA> _decisionToDFA;
  static antlr4::atn::PredictionContextCache _sharedContextCache;
  static std::vector<std::string> _ruleNames;
  static std::vector<std::string> _tokenNames;

  static std::vector<std::string> _literalNames;
  static std::vector<std::string> _symbolicNames;
  static antlr4::dfa::Vocabulary _vocabulary;
  static antlr4::atn::ATN _atn;
  static std::vector<uint16_t> _serializedATN;

  /* private parser declarations section */

  struct Initializer {
    Initializer();
  };
  static Initializer _init;
};

}  // namespace cyclone
